runtime

Thanks! Got it, I will add more examples for that. Currently you can do both: run dynamically untrusted code with eval, or run fully encapsulated logic (like in the existing examples). I made a small example that might give you a better idea (it's not eval, but shows how to isolate a specific data processing task): https://github.com/mavdol/capsule/tree/main/examples/javascr... And yes, you are spot on regarding LeetCode platforms. The resource limits are also designed for that kind of usage.

Hi everyone, I built a runtime to isolate untrusted code using wasm sandboxes. Basically, it protects your host system from problems that untrusted code can cause. We’ve had a great discussion about sandboxing in Python lately that elaborates a bit more on the problem [1]. In TypeScript, wasm integration is even more natural thanks to the close proximity between both ecosystems. The core is built in Rust. On top of that, I use WASI 0.2 via wasmtime and the component model, along with custom SDKs that keep things as idiomatic as possible. For example, in Python we have a simple decorator: from capsule import task @task( name="analyze_data", compute="MEDIUM", ram="512mb", allowed_files=["./authorized-folder/"], timeout="30s", max_retries=1 ) def analyze_data(dataset: list) -> dict: """Pro

I have been thinking about this myself, but am still not convinced about how to run untrusted Python code. I'm not convinced that the right solution is to run the code as WebASM [1]. I have been looking towards some kind of quick-start qemu option as a possibility, but the project will take a while. [1] https://github.com/mavdol/capsule

See the linked project at the end: https://github.com/mavdol/capsule

There's a link to the author's work here: https://github.com/mavdol/capsule (From the article) Appears to be CPython running inside of wasmtime

Hi there, Author here! I started building Capsule because I hit a wall with existing Python agent frameworks (fragile loops, lost state, no sandboxing). I felt we needed a proper infrastructure layer for this. This is an RFC / Architecture Preview. I'm currently implementing the core engine in Rust (publicly), but I wanted to share the design philosophy first. GitHub (API Specs & Roadmap):https://github.com/mavdol/capsule Deep Dive: https://capsuleruntime.substack.com/p/fine-grained-isolation I'd love to hear your thoughts on the Python API design (@task decorators) or the Wasm isolation approach!