clawss 0.1.1

A modular Python notebook environment with a browser-based IDE.

clawss

clawss is a modular Python notebook environment with a browser-based IDE.

It gives you a notebook-style workflow with a modular project structure.

With clawss:

• every cell behaves like a real .py file
• every cell runs in its own mutually exclusive namespace like normal Python files
• cells can import from other cells like normal Python modules
• you get a cell dependency graph, terminal, file previews, and package-style exports
• AI is optional and can use your own OpenRouter API key or local Ollama setup
• you can run on your own machine CPU/GPU or use your remote GPU runtime with your own provider API key

clawss is built for local, trusted use. It can run Python code and terminal commands.

Highlights

• Cell dependency graph

  • see how cells depend on each other
  • detect cycles
  • understand run order before running the notebook

• Model graph visualization

  • for PyTorch nn.Module models
  • inspect model structure inside the notebook UI
  • useful for debugging architecture shape and flow

• Project-style notebooks

  • upload files, preview files, use folders, and work with notebooks as part of a real project structure

• Cross-cell imports

  • cells can import names from other cells
  • each cell is treated like a modular Python file instead of a loose code block
  • each cell keeps its own execution namespace

• AI on your own money

  • AI can use your own OpenRouter key or your local Ollama setup
  • there is no hidden shared backend proxy for OpenRouter model calls
  • you can compare multiple models side by side

• Your own compute

  • local runtime works on your own CPU or GPU
  • remote runtime support exists for your own RunPod setup
  • remote GPU usage uses your own provider API key

Install

Base install:

pip install clawss

Install with visualizer support:

pip install "clawss[viz]"

Use the viz extra if you want the model visualizer and its optional stack such as PyTorch, torchview, onnx, and onnxsim.

Run

Start the app:

clawss module

Useful options:

clawss module --no-browser
clawss module --port 9000
clawss module --host 127.0.0.1

Other CLI commands:

clawss version
clawss info
clawss list
clawss clean

What those commands do:

• clawss version prints the installed clawss version
• clawss info shows install details, Python path, platform, and project storage information
• clawss list lists created projects
• clawss clean removes generated cache from created projects

What happens when you run clawss module:

• a local server starts on 127.0.0.1:8765 by default
• your browser opens automatically
• the app is available at http://localhost:8765

Basic workflow

1. Open clawss
2. Create a project
3. Create or upload a notebook
4. Add cells and run them
5. Use the Project tab to work with files, folders, uploads, and previews
6. Use the dependency graph to understand cell relationships
7. Use the visualizer for supported PyTorch model cells

AI usage

AI in clawss is optional.

• you can bring your own OpenRouter API key or use your local Ollama setup
• the app can talk to OpenRouter or Ollama depending on the provider you choose
• you can select multiple models and compare their outputs
• AI can help with writing, formatting, explanation, refactoring, and error assistance

Important:

• AI usage costs are your own
• clawss itself is completely free and does not charge anything

Runtime and GPU usage

clawss supports more than one runtime style:

• Local runtime

  • runs on your own machine
  • if your Python environment has GPU-enabled libraries and your code uses them, that is your compute

• CPU-only local runtime

  • supported when you want a CPU path explicitly

• Remote runtime

  • supported for your own RunPod-backed runtime configuration

Important:

• GPU costs are your own
• remote runtime costs are your own
• clawss does not provide hosted compute and does not charge anything itself

Why the dependency graph matters

The dependency graph is one of the core ideas in clawss.

It helps with:

• understanding upstream and downstream cell relationships
• avoiding hidden notebook state problems
• detecting cycles
• running cells in dependency-aware order
• making notebooks easier to reason about as they grow

Why the visualizer matters

The visualizer is especially useful for model-heavy notebooks.

It helps with:

• seeing model structure without printing giant object trees
• understanding flow through layers
• verifying model shape expectations
• exploring architectures inside the same notebook workflow

Install note:

• use pip install "clawss[viz]" if you want the visualizer dependencies installed automatically

License

MIT. See LICENSE.