Why I Tied My IDE to a Contract: The Story Behind Juni's EULA

JunoEngine Devs — Fri, 24 Jul 2026 20:27:50 +0000

When you're building developer tools, licensing is usually an afterthought—a standard MIT or Apache boilerplate you copy-paste from another repo and never look at again. But when I set out to build Juni IDE, I decided to do something a bit unconventional: I baked a mandatory legal contract right into the core usage agreement, including a $200/month commercial license threshold for larger businesses.

If you're thinking, "Requiring a contract for an IDE? That sounds like a great way to kill adoption," hear me out. Let's talk about why I did it, how it works, and what it means for developers and companies using Juni.

The Core Philosophy: Free for Hobbyists, Fair for Enterprise
When building software like desktop installers (macOS, Windows, Linux), web IDEs, and PWA builds, sustainability is the hardest problem to solve. Open-source is amazing, but solo maintainers often burn out trying to support enterprise teams who pull in millions in revenue while contributing zero back to the tooling they rely on.

To solve this, the Juni End User License Agreement (EULA) is structured around a simple principle:

Personal, hobby, and small business use: Completely free. No fees, no friction.
Commercial scale ($1M+ / Small Business threshold): If your company grows beyond the defined small business limits, a commercial license is required at USD $200/calendar month.

The Rule of Thumb: If your organization scales past the small business threshold, supporting the infrastructure and development of the tool via a $200/mo commercial license isn't just a fee—it's ensuring the IDE you build your products on stays alive.

What You Actually Own (Spoiler: Not Your Source Code)
One of the biggest anxieties developers have with specialized IDEs or proprietary engines is vendor lock-in or loss of ownership over their creations.

We made sure Juni's EULA explicitly protects the creator:

Your projects remain yours: Your source code, assets, scenes, and exported games belong 100% to you. The EULA doesn't claim rights to your content.
The Export Exception: You are totally free to distribute your content (even commercially) using the normal exported runtime files.
The Fine Print: Acceptable Use and Enforcement
Of course, a binding contract has teeth. Under the EULA, using Juni means agreeing to a few non-negotiable boundaries:

No reverse-engineering, redistributing, rebranding, or selling the Juni IDE/app binaries themselves.
No bypassing the commercial license requirements if your company exceeds the small business thresholds.
Standard safety guards: No malware, no IP infringement, and no removing required copyright notices from the IDE or exported runtimes.
As for liability? Juni is provided “AS IS”, with damages capped strictly at the fees you paid for commercial access in the previous three months (or zero if you're on the free tier).

Why This Matters for the Ecosystem
Tools aren't built in a vacuum. By establishing a clear, legally binding contract upfront, it sets clear expectations between indie creators and corporate consumers. If a company is making over a million dollars in revenue, paying $200/mo for the IDE powering their workflow shouldn't be a hurdle—it should be a no-brainer.

What do you all think about tying developer tools to revenue-based commercial contracts? Have you ever had to navigate licensing hurdles like this in your own projects? Let me know in the comments below!

Juni: Python and C++ United in JunoEngine WebApp

JunoEngine Devs — Sat, 18 Jul 2026 01:21:00 +0000

Hello Devs!: Juni – a Python-feel systems language that compiles to WASM for games built on a custom software called JunoEngine

URL

https://junoengine.netlify.app or https://juno.pythonianviper.workers.dev/

The Hotpockets

I built Juni, a statically typed systems language that aims for Python-level readability with C++-ish control: no GC, explicit memory/refs, and a compiler that targets WebAssembly. Juno is the repo around it — browser IDE, Tauri desktop shell, and a small game/sim runtime.

Why

I wanted one language that could author game logic and run it in the browser without a JS/TS game-script layer as the source of truth. Juni compiles to WASM; the host is a thin JS runtime (Canvas2D, WebGPU 3D, input, audio, ECS scenes).

What’s in the box (v9.2)

Compiler in Rust (parse → check → WASM codegen), plus LSP bits
Browser IDE (Vite + Monaco) with compile/run in-tab, scene editor, tile brush, 3D Edit viewport on WebGPU
Entity scripts: .jscene handlers map to WASM exports like player_on_update
Optional on-device AI via WebLLM (off by default)
juni export-web for static game builds; desktop installers via Tauri CI
Apache-2.0 source; distributed IDE also has an EULA
Interesting bits / tradeoffs

Language surface is deliberately small — enough for frames, entities, and host calls, not a general OS language yet
Browser “LSP” is WASM hover/diagnostics, not a full language server process
3D is a slice (mesh/light/camera + world_draw3d), not a full engine competitor
Themes and a silly Cat Coffee panel exist because the IDE is also a place I actually sit in
Try it

Open the IDE, hit Run (⌘/Ctrl+Enter). There are tutorials and a platformer example in-repo.

Repo: https://github.com/AJpro774/Juno

I’d love feedback on the language surface, the WASM entity-script ABI, and whether the IDE feels usable for small 2D/3D prototypes.

DEV Community: JunoEngine Devs

Why I Tied My IDE to a Contract: The Story Behind Juni's EULA

Juni: Python and C++ United in JunoEngine WebApp