UI

• Browser-Native — No installs to start building. Ready to go native when you are.

• Monaco Editor Inside — The same editor that powers VS Code, tuned for Crash BASIC.

  • Full BASIC syntax highlighting and bracket matching
  • Multi-cursor editing, column selection, find & replace with regex
  • Code folding and minimap navigation
  • Inline error markers and tooltips driven by the live interpreter
  • Familiar keyboard shortcuts — your VS Code muscle memory works on day one
  • Hotkeys wired into the IDE:
    • F1 — jump to contextual help for the keyword under the cursor
    • F4 — open the Resource Manager
    • F5 — run your app, with a hot push to the native CrashPlayer if you've got it
    • Shift+F5 — start the debugger

• Sprite Editor — A pixel-art workstation that holds its own against the desktop tools.

  • Drawing tools — pencil, line, rectangle, rounded rectangle, ellipse/circle, bucket fill, fill-erase, eraser, eyedropper, and color-swap
  • Pixel-art shading tools — dedicated Highlight and Shadow brushes that sample neighboring pixels to brighten or darken naturally, plus a colored-Outline tool — shade and rim sprites without hand-picking lighter and darker swatches every stroke
  • Selection tools — rectangular marquee, free-form lasso, and magic wand, with move-selection for repositioning chunks of pixels
  • Layers per frame — visibility, opacity, blend modes, rename, and reorder; every frame keeps its own independent layer stack
  • Animation timeline — multi-frame editing with duplicate, insert, delete, and reorder, onion-skin overlay of adjacent frames, and a live FPS-driven preview panel
  • Reference image — drop a photo or concept art onto the canvas with adjustable opacity (0–100%) to trace or match
  • Palette tools — editable color palette and swatches, with a default palette to start from
  • Zoom and pixel grid — variable zoom and a toggleable grid overlay for detail work
  • Single-letter hotkeys for every tool — B pencil, N outline, H highlight, D shadow, E eraser, G fill (Shift+G fill-erase), I eyedropper, L line, U rect, R rounded rect, O circle, M marquee, S lasso, W magic wand, V move, P color swap
  • Full undo/redo history across all of it
  • Real clipboard support — copy and paste sprite frames or selections; the OS clipboard round-trips as PNG, so the same pixels move between Sprite Editor, Tile Editor, and external tools like Photoshop, Aseprite, or a browser
  • Aseprite round-trip — open and save real .ase / .aseprite files with layers and frames intact, so existing Aseprite work flows in untouched
  • PNG and spritesheet import/export for everything else

• Tile & Map Editors — Build whole levels without leaving the IDE.

  • Multi-layer maps (background, foreground, collision, etc.)
  • Brush, stamp, and fill painting tools
  • Autotile and terrain tools for connected tilesets
  • Drop collision boundaries and spawn points directly on the map
  • Animated tile preview — watch your animated tiles cycle right in the editor as you build the map
  • Real clipboard support — copy and paste whole tiles or selections; the OS clipboard round-trips as PNG, so pixels move freely between Tile Editor, Sprite Editor, and external tools like Photoshop, Aseprite, or a browser
  • Aseprite tilesets import and export with layers preserved — share one source file across tools, no conversion step

• Music Tracker — A full chiptune-and-beyond studio inside the IDE.

  • Three synchronized views over the same song: Piano Roll, Drum Step Sequencer, and MML Editor
  • Multiple songs per project with per-song BPM and loop control
  • Scale-aware piano roll — in-key rows highlighted, chord tones highlighted, root note marked
  • MIDI input — step-record (one note per key press) or live-record (real-time timing and held duration)
  • Chord Helper panel for quick chord drops at the cursor
  • Chord Builder for sustained chord beds and Arpeggiator for melodic chord progressions
  • Drum pattern library — generate beats from presets and save your own as reusable patterns
  • Play it from your BASIC code — songs save to music.cbm in the project, and PLAYMUSIC "songname" plays them straight from the engine. No export step, no embedding, no asset wrangling
  • Optional WAV / MP3 export for sharing tracks outside the IDE, plus copy-as-MML for pasting into source

• Instrument Editor — Build your own sound bank, not just pick from presets.

  • Multi-layer instruments with per-layer envelopes (ADSR)
  • Live envelope visualization while you tweak
  • Drop in WAV samples with Resample or Timestretch pitch modes
  • Auto / Manual / explicit loop-point modes for sustained samples
  • MIDI keyboard preview routes straight to the instrument you're editing
  • Save and load full instrument banks as .cbi files

• Live Debugger — Real debugger, not just a print-and-pray loop.

  • Pause, resume, and stop a running program at any time
  • Step Over (F10), Step Into (F11), and Step Out (Shift+F11) — drive execution line by line
  • Set and toggle breakpoints by clicking the gutter; manage them in a dedicated panel
  • Live Variables panel shows current values across global, local, and FOR-loop scopes
  • Call Stack panel lets you jump between active functions, subroutines, and threads
  • Current-line highlighting in the editor follows execution as it moves

• Dockable Workspace — Drag, snap, and arrange widgets to fit how you work.

• Built-in Help — Every keyword, statement, and sample one search away.

• GitHub & Local Folder Sync — Your project lives where you want it.

  • GitHub integration — sign in, pick a repo, and pull or push commits straight from the IDE
  • Commit messages and branch awareness baked into the sync flow
  • Divergence detection — if the remote moved since your last sync, the IDE stops and asks before clobbering anything; pick force-push or force-pull rather than silently losing work
  • Local folder sync via the Chrome File System Access API — keep an actual on-disk folder in lockstep with the IDE
  • Manual Sync Now / Pull / Push All controls — never a surprise overwrite, your call when bits move
  • Mix and match: clone from GitHub, edit, snapshot to a local folder, commit back — same project either way

• Arcade Publishing — Send your game live to Crash BASIC Arcade in a click.

• VS Code Extension — Prefer your own editor? The toolchain ships there too.

• Multiplayer-Ready — Wire games up to CrashNet and play live with friends.

• Always Evolving — New features land continuously.

Language and Engine

Write once. Run anywhere CrashPlayer runs.
Your game lives in a portable .crashcart — code, art, music, all bundled together. The CrashPlayer runtime takes it from there: macOS, Windows, Linux, iOS, Android, and the web (with full multithreaded WASM). tvOS coming soon. No compile step (unless you want to). No port. No "web version" of your game.

No engine tax.
Not built on Unity. Not built on Godot. Not built on Unreal. No royalty cliff, no per-seat license, no surprise pricing email. Crash BASIC is the engine — top to bottom, ours and yours.

The language is the game engine.
Sprites, particles, shaders, an FM/sampled synthesizer, MP3/WAV/video, fonts, networking — every one of them is a one-line statement. Nothing to import. Nothing to wire up.

Multiplayer is a keyword, not a project.
Drop in a CRASHNET block and your game becomes server-authoritative multiplayer — same source runs on the host, the player-server, and the client. IF ME.ISHOST THEN… is all the wiring you need.

Inline RPC. No glue code.
WITH PLAYER 3 SEND ... END WITH runs that block on player 3's server-side interpreter. WITH CLIENT SYNC ... END WITH runs it on the local client and waits for an ack. The compiler hoists each WITH block into a synthetic event handler, registers it everywhere, and rewrites the call site — so you write what runs where in plain code. No manual handlers. No argument serialization. No "shared protocol" project to keep in lockstep.

Host the multiplayer your way.
CrashNet servers are yours to run anywhere — your VPS, your container, your dedicated box, your home server. You own the uptime, the data, the rules. Managed multiplayer hosting on CrashBASIC Arcade is in pilot now, with general availability targeted by or before Q4 2026 for studios that would rather skip the ops.

Compose music in your code.
Crash BASIC ships with a full Music Macro Language. PLAY "T140 O4 L8 CDEFGAB>C" is a song. Chords, ties, dotted notes, staccato/legato articulation, tempo and volume control, polyphonic mixing, multi-track .cbm arrangements with patterns, per-track channels and instruments, and arrangement steps — all from string literals.

A real synthesizer, not a sample player.
ADSR envelopes, FM modulation, biquad filters (lowpass/highpass/bandpass/notch) with resonance, LFO vibrato/tremolo/PWM, filter envelopes, up to 32 polyphonic voices at full sample rate. Optional Retro mode (8-voice, 32 kHz, Gaussian interpolation) when you want SNES-style character on purpose — never as a ceiling.

Stack samples and oscillators in the same instrument.
Attach a WAV file to any instrument layer and it behaves like another oscillator — layer it with a square wave, run it through the ADSR, filter it, FM-modulate it, vibrato it. A real piano sample under a triangle-wave attack, with shared envelope, in one instrument definition. Layer as many oscillators and samples as your instrument needs.

67 built-in instruments. Or sample your own.
Sine, square, triangle, saw, pulse waves. FM pianos, synth leads, strings, pads. Drums, lasers, explosions. Chiptune-style patches when you want that flavor. Then bring your own — sample any real instrument, voice, or field recording into a .cbi pack and stack it with the built-ins. A full studio palette, not a fixed soundboard.

Real concurrency. BASIC-flavored syntax.
CALL THREAD, CALL TIMER, CALL RENDER, CALL EVENT — multithreaded, event-driven games without async/await ceremony, callback pyramids, or Mutex<Arc<RwLock<…>>> plumbing. Readable like BASIC; backed by a modern Rust runtime.

No thread starves the others.
The runtime tracks yield points behind the scenes. A thread that burns through ~100,000 statements without yielding gets halted with a real error — not a silent hang, not a frozen window. PAUSE, DELAY, YIELD, and every CALL TIMER/THREAD/EVENT entry yields implicitly, so cooperative code never trips it. Tight loops that would silently freeze other engines tell you to fix them in CrashBASIC.

A debugger that talks to your running game.
Set breakpoints in the browser-based IDE, step through code executing inside the native player, over the wire. Hot push a build with one keystroke.

Loud errors. Meaningful messages.
CrashBASIC refuses to fail silently. When something breaks, you get a real message — the keyword that failed, what it expected, what it got, and a hint to fix it. Division by zero, undefined function, missing shader, wrong arg count — they all surface with context, not cryptic stack traces. And what isn't an error doesn't get dressed up like one: non-error outcomes come back as values, not exceptions.

Any 2D game. Any resolution.
WebGPU (wgpu) renderer across every platform — desktop, mobile, browser. Pixel-perfect retro sprites or hand-painted hi-res. Tight 256×240 NES-tribute screens or full 4K. Thousands of sprites on screen at once, with texture size capped at whatever your GPU actually supports — not artificially boxed in by the engine. The same GPU pipeline production engines use. If it's 2D, it belongs in CrashBASIC.

Every input, every device.
Keyboards, mice, gamepads, joysticks, multi-touch — all unified under one input API. Need a controller on a phone? Flip on the virtual gamepad overlay and your console-style game gets a touch UI without changing a line of input code. And the overlay is yours to shape — reposition buttons (GAMEPAD BUTTON "A" AT 0.8, 0.6), skin them with your own art (GAMEPAD SETIMAGE), remap to any key (GAMEPAD MAP), set transparency (GAMEPAD ALPHA), or toggle DPad versus joystick mode. Default works out of the box; custom is one BASIC line per change.

Ship it once. It works forever.
Package your .crashcart together with the CrashPlayer runtime into a self-contained installer — no "download our player first" friction. Redistribute CrashPlayer with your game on every supported platform, no extra license required. And the runtime you ship with is frozen — no forced updates, no API churn, no patch-Tuesday breakage. The CrashPlayer your game shipped with is the CrashPlayer it runs on, on day 1 and day 3,000.

Fix forward. Future forward.
We move fast and stay current. Bugs get fixed in the next release, not patched into yesterday's — and the next release is usually hours or days away, not months. (We've pulled a build occasionally for a severe bug; it's rare.) When the choice is between adopting a new platform capability and dragging legacy hardware along, we choose what's next. Your shipped game still runs on the frozen runtime you bundled with it; the platform itself stays alive, current, and moving.

Two ways to reach players.
Ship your .crashcart as a standalone installer with the runtime bundled in — your code, your assets, your frozen runtime, all in one. Or publish it to CrashBASIC Arcade, where players play directly in the browser via the feature-identical WASM build. Multiplayer games seamlessly hand off to the native CrashPlayer (downloaded right from the Arcade) for the networking edge it needs — same .crashcart, same game, same gameplay. One .crashcart. Two distribution paths. Zero extra work for you.

Embed it anywhere. At full speed.
Multi-threaded WASM needs cross-origin isolation headers (COOP/COEP) — headers that quietly break ads, analytics, embeds, and most CMS plugins on your own site. Host your game on the CrashBASIC Arcade and embed it anywhere with a single <iframe>: full multi-threading inside the embed, full WebGPU rendering, zero header configuration on your end. We carry the cross-origin tax. You keep your site working. Inline in-page embedding on Chromium-based browsers (Chrome, Edge, Brave, Arc, Opera). Other browsers open the game in a popout window — and we're always working to expand inline support as the web platform catches up.

Free to distribute. License to monetize.
Ship your .crashcart anywhere, free, forever. A flat annual Indie or Studio license unlocks monetization and lets you reduce or remove the CrashPlayer splash. No revenue share. No per-install fees. You keep 100% of what your game earns.