A Sinatra-flavoured web framework that compiles to a native binary via Spinel. You write a Sinatra-style app.rb:

require 'sinatra'

get '/hi/:name' do
  "hi, " + params[:name] + "!"
end

…and get ./app — a single static executable, ~80 KB, no Ruby runtime, doing ~150k req/s. Beyond routing / sessions / templates, the batteries ↓ cover auth (bearer / cookie / OAuth2), SQLite, opt-in PostgreSQL, WebSockets, Broadcast + Presence + LiveView, an MCP tool catalog, TLS, a pooled HTTP client, and an OpenAI-compatible LLM client + server.

Current release: v0.11.5 on RubyGems — gem install tep. Pre-alpha; API still in motion.

A new project (the simple path). The Spinel toolbelt (bundler-spinel) scaffolds a project and provisions the Spinel compiler for you:

gem install bundler-spinel
spinel-compat init my_app && cd my_app
./bin/build            # ensures tep, vendors deps, provisions Spinel, compiles → ./app
./app -p 4567

spinel-compat init writes a Gemfile (gem "tep"), an app.rb, and a bin/build. The build step provisions a pinned Spinel compiler (cached under ~/.cache/spinel), vendors dependencies where Spinel can follow them, and compiles app.rb to a native binary — no Ruby runtime in the result.

Your app.rb is plain Sinatra-flavoured Ruby:

require 'sinatra'

get '/' do
  "hello from Tep"
end

get '/hi/:name' do
  "hi, " + params[:name] + "!"
end

Already have a Sinatra app? Scaffold a project and use your source as its app.rb — the build reports any Spinel-incompatible patterns:

gem install bundler-spinel
spinel-compat init my_app && cd my_app
cp /path/to/your_app.rb app.rb
./bin/build                      # → ./app  (or a clear report of what won't translate)

The tep translator is also on RubyGems on its own (gem install tep) for use in your own build scripts, once a Spinel engine is on $SPINEL / PATH.

# 1. Spinel (the AOT compiler)
git clone https://github.com/matz/spinel && cd spinel && make all
export PATH="$PWD:$PATH"

# 2. tep
git clone https://github.com/OriPekelman/tep && cd tep && make all
./examples/hello -p 4567

# your own app
tep build hello.rb       # → ./hello (~80 KB binary, no Ruby runtime)

The translator (bin/tep) needs CRuby >= 3.2 with the prism gem installed (a development-only dependency — bundle install brings it in). Prism ships with the stdlib from 3.4 onward; on 3.2/3.3 it's a gem install. Recommended Ruby manager: rv — fast version+gem manager from the Spinel Cooperative (separate project from the matz/spinel AOT compiler Tep compiles through; same Ruby neighbourhood). .ruby-version in this repo pins 4.0.0; rv shell makes rv run rake test just work. Build deps on Linux: build-essential, libsqlite3-dev. macOS: Xcode CLI tools.

For a full walkthrough — auth, persistence, deploy — see the Getting started wiki page.

Yes. ~150k req/s on a small Linux server with the request path doing actual work (SQLite SELECT + JSON), microsecond median latency. The hot path is C from end to end (epoll, request parsing, dispatch, response writer); the Ruby you wrote is compiled, not interpreted. HTTP/1.1 keep-alive and prefork with SO_REUSEPORT are the usual wins applied.

Two scenarios, both wrk -t8 -c256 -d10s on Linux 6.x / aarch64, 8 workers a side (Sinatra: 8 workers × 4 threads):

Numbers are conservative floors; a clean re-run on a quiet host is expected to come in higher. Reproduce with bench/run_all.sh.

macOS note. Linux is Tep's primary deployment target. Builds and runs on macOS too, but Darwin's SO_REUSEPORT doesn't load- balance new connections across prefork workers — a single long- running response on the busy worker blocks every other request on the same listener. On Linux 3.9+ the kernel distributes accepts correctly, so prefork scales as the table above. The path forward for tep apps that need real concurrency on macOS is Tep::Server::Scheduled (one worker, fibers per connection) + a cooperative Tep::Http — design + phases in docs/MACOS-CONCURRENCY.md.

Sinatra-shaped routing, filters, responses, templates, sessions, plus a collection of "batteries" — pure-Tep modules that cover the gem ecosystem's most common needs in a way that lowers cleanly through Spinel.

Per-battery API docs and cookbooks live on the wiki. The full Sinatra-compatibility matrix is in SINATRA_COMPAT.md.

The last four batteries (Tep::Auth, Tep::Broadcast, Tep::Presence, Tep::LiveView) ship a small framework for "web apps in a live agentic age" — req.identity is always a principal+delegate pair so agents acting on behalf of humans are first-class through every battery. The end-to-end design

• a realistic chat-room scenario walked through every seam lives in docs/BATTERIES-DESIGN.md.

430 tests pass make test (serial, ~13 min on the gx10) or make test-parallel (subprocess fan-out, ~4 min — see test/run_parallel.rb). End-to-end demos that build and run:

• examples/counter/ — the smallest Tep.live demo. Shared integer counter; click in one tab, every other tab updates in <100ms. ~80 lines of Ruby + CSS, no JS to write (the bootstrap shell wires data-event clicks through the WS).
• examples/experiments/ — the Tep::MCP battery demo. Mock training-run manager driven by an MCP client (Claude Code / OpenCode / Gravity): 4 tools, 2 resources, capability gating, auto-published /llms.txt + /openapi.json + /mcp JSON-RPC. ~200 lines of Ruby plus an AGENTS.md worked example.
• examples/agentic_chat/ — the four-battery agentic demo. Sub-second WS push, multi-user chat, agent-spawn with OAuth2-style delegation. ~270 lines.
• examples/chatbot/ — minimalistic OpenWebUI-style client backed by any OpenAI-compatible endpoint (Ollama / OpenAI / toy's toy serve) exercising the full pre-agentic battery surface (Tep::Server::Scheduled + Tep::Llm + Tep::SQLite + Tep::Streamer + Tep::Session + Tep::Password + Tep::Jwt + Tep::Security::{Cors,Headers} + Tep::Assets + SpinelKit::Json + Tep::Job + SpinelKit::Log) in ~1500 lines of Ruby + HTML + CSS + JS.
• examples/llm_gateway/ — the Tep::Proxy streaming demo. Block-form DSL gateway in front of an OpenAI-compatible upstream; pumps SSE token deltas straight through to the client and emits one Tep::Events inference event per completed stream.
• examples/api_gateway/ — the buffered-proxy demo. Capability-gated forwarding with before_forward
  • after_forward observability hooks; same DSL, non-streaming.
• examples/websocket_echo.rb — Tep::WebSocket in isolation; test/test_websocket_echo.rb performs a real RFC 6455 handshake over a raw socket and round-trips a masked TEXT frame.

sig/ ships RBS signatures for tep's public surface, mirroring lib/tep/. They're for IDE tooling today (Solargraph, RubyMine) and for forward compatibility with spinel-side RBS consumption (discussion at #6) — the goal is to let library authors carry the type-correctness burden in .rbs files so app developers can write idiomatic Ruby without the inference-warming seed dance that currently lives at the top of lib/tep.rb. rake rbs:validate syntax-checks the tree.

tep build accepts either the Sinatra DSL or a lower-level Tep-class style without the translator:

require_relative '../lib/tep'

class Hi < Tep::Handler
  def handle(req, res)
    "<p>hi, " + req.params["name"] + "!</p>"
  end
end

Tep.get "/hi/:name", Hi.new
Tep.run!(4567, 1, false)

Useful for tracing where the translator's textual rewrites go.

Tep deliberately exists to find Spinel's edges. If you hit a Sinatra idiom that doesn't translate, a Spinel-emitted miscompile, a runtime hang — please file an issue with a minimal reproduction. "Your app doesn't build" is a useful data point.

MIT, see LICENSE.