Jouncesingle-file → full stack

v0.8.2 — 640/640 tests — 0 known bugs

You shouldn’t have to glue ten tools together just to build a modern app.

Meet Jounce — the AI-native, single-file full-stack language that does it for you. Build production-grade apps without switching contexts. One file. Full output. Zero boilerplate.

Imagine needing software — a dashboard, a form, an API, a game — and being able to create and deploy it on the fly. No framework setup. No bundler configs. No servers to wire together.

LLMs are great at generating a single long page of code, but they struggle to piece multiple files together and keep them in sync. Jounce lets humans and machines build in one unified .jnc file — keeping every component, function, and style on the same version.

View repo on GitHub Getting started

One file → multi-target compilation

app.jnc

↓ jnc compile

├── server.js (Node.js SSR)

├── client.js (reactive runtime)

├── styles.css (scoped)

└── index.html

Write once. Deploy anywhere. No manual wiring. No CSS-in-JS runtime.

Why Jounce Exists

Modern software development has become a patchwork of tools — frameworks, bundlers, servers, routers, CSS systems, deployment pipelines, and now AI integrations. You spend more time wiring things together than building your actual idea.

LLMs made this even clearer: they can generate beautiful single files of working code, but as soon as your project splinters into dozens of files and configs, they lose track. Versions drift, components desync, and the AI assistant becomes unreliable.

Jounce closes that gap with a single, coherent language and runtime where everything lives in one .jnc file. No mismatched versions. No dependency hell. No context switching.

How Jounce Works

Jounce takes a single .jnc file and turns it into everything a modern app needs. The compiler, built in Rust, understands what runs on the client, what runs on the server, and what can be pre-generated.

From one file, Jounce can emit:

• server.js — server/runtime logic
• client.js — interactive UI
• styles.css — scoped, component-aware styles
• index.html — page shell

That means you can deploy anywhere without wiring React + Express + Webpack + Tailwind + 5 other things.

app MyApp {
  title: "Hello Jounce"

  route "/" {
    view {
      <h1>Hello from Jounce</h1>
      <button on:click={count++}>
        Clicked {count} times
      </button>
    }
  }

  state count = 0
}

Why Jounce?

You wanted a language that AI can help write, but that still outputs clean, production-ready artifacts. Jounce bakes in reactivity, JSX, styles, and templates so you don’t have to glue five tools together.

Fine-grained reactivity

Signal tracking, computed values, batch updates, even reactive method calls like .map().

Component-scoped styles

Automatic scoping with hash-based class names. No runtime styling tax.

JSX everywhere

Components, lambdas, lists, conditionals — all in one file.

Production-ready

640/640 tests passing, 0 known bugs, 25+ example apps, MIT license.

From .jnc to running app

Jounce’s compiler handles parsing, AST, reactivity analysis, style compilation, and JS emission — so your output is ready to drop into Node or the browser.

component TodoApp() {
  let todos = createSignal(["Buy milk", "Walk dog"]);
  let newTodo = createSignal("");

  let addTodo = () => {
    if (newTodo.value.length() > 0) {
      todos.set([...todos.value, newTodo.value]);
      newTodo.set("");
    }
  };

  <div class="app">
    <h1>My Todos ({todos.value.length()})</h1>
    <input
      value={newTodo.value}
      onInput={(e) => newTodo.set(e.target.value)}
      placeholder="Add todo..."
    />
    <button onClick={addTodo}>Add</button>
    <ul>
      {todos.value.map((todo) => {
        return <li>Task: {todo}</li>;
      })}
    </ul>
  </div>
}

style TodoApp {
  background-color: #f5f5f5;
  padding: 20px;
  border-radius: 8px;
}

Compiler outputs

CLI

cargo run --release -- compile app.jnc
# → dist/server.js
# → dist/client.js
# → dist/styles.css
# → dist/index.html

Prefer the dev flow?
jnc init my-app --template counter → cd my-app → jnc dev → open http://localhost:3000.

Quickstart

Jounce is written in Rust. Build the CLI once, then use jnc anywhere.

Install from repo

git clone https://github.com/Jounce-lang/jounce-pre-production.git
cd jounce-pre-production
cargo build --release

# optional: add to PATH
export PATH="$PATH:$(pwd)/target/release"

Create & run an app

jnc init my-app --template counter
cd my-app
jnc dev
# open http://localhost:3000

Starter templates (built in)

Skip boilerplate — Jounce ships with 5 interactive templates and 25+ example apps.

Blank

Minimal starting point

jnc init my-app --template blank

Counter

Signals + events + reactivity

jnc init my-app --template counter

Todo

Arrays, forms, computed values

jnc init my-app --template todo

Form

Validation and error states

jnc init my-app --template form

Dashboard

Multiple components + layout

jnc init my-app --template dashboard

Roadmap

Transparent phases. Core language, reactivity, and styling are done — now we layer on DX and app features.

✅ Complete

Phase 11–13

Module system, fine-grained reactivity, style system & themes.

🚧 In progress

Phase 14 — Database integration

ORM, queries, migrations.

📋 Planned

Router, forms, v1.0 (Q2 2026)

Client/server routing, validation, DX improvements.