bicycle

open something. bike becomes it.

open a folder, bike is a grid. open an html file, bike is the live page. open a video, it plays. open code, you see what changed since you last saved. the file picks the tool.

the extension is the only decision. .md, you write. .mp4, it plays. .mp3, it plays. .png, it renders. .pdf, it opens. .obj, 3D. .html, live page. if it's a file, bike renders it. no mockup, no export, no handoff. when it's done, it's done.

every extension
pages
html — live, editable in place
styles
css — a living style guide, every rule previewed doing its job
writing
md, txt — a block editor
code
js, ts, py, go, rs, c, java, sql, and friends — always a diff
data
json, csv, xlsx, sqlite
documents
pdf, docx, rtf, idml — an indesign layout renders, spreads and all
drawing
svg — a full vector editor
type
glyphs, otf, ttf, woff2 — a type lab, a specimen
media
images render, audio and video play — hover a card and it plays
3d
obj — orbits, auto-rotates, takes your theme
disk image
dmg — unpacked to its app icon
anything else
“no view for .xyz, create one?” — click it and claude writes one
a folder
a grid. with an index.html, the folder is that page
over 20 mb
the name and the size, nothing more

1   get in

type your email and hit enter. we send a token to your inbox — paste it back. new or returning, it's the same move. that's the whole login.

no passwords, no admin panel that can read your files. the token is your key; email just delivers it, so losing it only takes another email to recover. nothing leaves your machine unless you push it.

the fine print
no account
bike still runs — local folders, local git, your own claude. nothing is held back
the browser
cloud projects open on the web too — same files, same chat, no install
free
1 GB, sync, publish, share
pro
$5/mo · 10 GB · $3 for students
students
free. software, AI, all of it — bicycle.school
the app
updates itself, silently, every launch
a cloud run
a sandbox with nothing in it but your repo
your work
a folder on your disk. it was never ours

2   home

your work is yours.

the filesystem is your database.

home is a grid. every project is a card — the ones on your machine and the ones in the cloud. open one and you're inside it. a card shows its name, its branch, who else is in it, and a thumbnail that is the file itself.

your work lives at you.bicycle.computer, a portfolio that builds itself as you publish — repos, sync status, which folders are live, custom domains, who you've shared with.

every gesture
click a card
select. adds. click the name to rename in place
double-click
open. a cloud repo clones itself first
drag a card
into a folder — or onto a breadcrumb
pinch the grid
one to eight columns
drop files in
a folder fills as it copies, file by file
paste
an image becomes a file. a url becomes a link card. a paragraph becomes a note. a sentence becomes a prompt
the project name
settings, sharing, domains, history
settings
.bike/settings.json — theme, instructions for claude, thumbnail, sync. a file, in your project, in git

3   think

we're not in canvas anymore.

press any letter and just think. it's chat, but it acts: claude reads your project, writes files, and builds things right where you are — drafting a page, organizing the folder, making a card from a link you paste. coworker, not oracle.

hold control to speak instead of type. ⌘ enter crystallizes a thought into a file. press space to see the conversation. git, AI, sync, publishing live in the same surface — fork anything public, send a pull-request back, nothing to configure, nothing to install.

everything it can do
it sees
the project, what's open, what you selected, what your other chats are about
it acts
reads, writes, moves, runs shell, git, the api. it never stops to ask permission
selection
“this” and “here” point at what you highlighted — prose, an element, a css rule, a file
click a tool line
jumps to the file it touched, lands on the exact text it changed
comment dots
a conversation about a line leaves an avatar on that line
images
$BIKE_IMAGE "prompt" — 4¢
video
$BIKE_VIDEO image.png "prompt" — an image animated, 50¢
background chats
$BIKE_CHAT — another agent beside you, it tells you when it lands
your chats
cloud chats gather into one list — every project, desktop and web, faces on the shared ones. a local project keeps its own to itself
the model
opus 4.8 on a bike account, or bring your own claude — then the AI is free, forever
a turn
ends with a bell. click the dots to stop it

4   make

make it from nothing.

the empty grid is where things begin. the gesture picks the medium — no menu, no new-file dialog. double-tap and it's a folder. drag and it's a drawing. hold and it's recording.

the gesture makes an empty file; opening it makes the content. no formats to choose, no templates to pick. the motion is the decision, and the grid fills as you go.

every way in
double-tap empty space
a folder
drag empty space
a drawing — the stroke you started is already the first line
hold empty space
a recording — the mic is live before the file exists
the +
one card per kind. what bike can't make empty, claude makes instead
the + in a file
adds structure, not files — blocks in markdown, shapes in a drawing, tags in a page, rules in a stylesheet, keys in json
ask
an image, a video from an image, a page, a whole project

5   see

every file has a view — and the view is its thumbnail. no view for a kind of file yet? ask for one. claude writes it into .bike/views and every file of that type renders with it.

the tool that shows a thing is just a file in the folder. flip the eye to fall back to the built-in.

the contract
ask for one
claude writes .bike/views/<ext>/index.html — every file of that type renders with it, at once
the api
your page gets ?src=/path. fetch it, draw it. that's all of it
it's a page
so you author it live, like any other page in the project
thumbnails
a card renders with the real view. an html folder shows the running site. an empty file shows the drawing of what it will be
a cover
thumbnail in settings — any file becomes the project's card

6   edit

one grammar, every format.

a file is made of nodes the way a folder is made of files. blocks in writing, elements in a page, rules in a stylesheet, shapes in a drawing, keys in data — and every node answers to the same moves: click selects, double-click goes deeper, drag moves, delete removes, ⌘ z undoes.

so there's nothing to learn per format — only what a node is changes. every kind of file edits in place. nothing exports, nothing imports — it's all just the folder.

every editor
everywhere
click selects. double-click enters. drag reorders and reparents. the panel is the tree, the + adds a node, names rename in place. delete — or backspace — removes it. ⌘ z undoes, and restores your selection
writing
the nodes are blocks — rendered until you're in one, then markdown, then rendered again. enter splits, backspace merges, selects whole blocks, tasks are real checkboxes, the outline is the panel
pages
the nodes are elements, and the html file is the running page. picks deep, every attribute is editable, ⌘ g wraps. the source changes surgically — comments and formatting untouched
styles
the nodes are rules, each previewed doing its job — keyframes animate, gradients paint, font-faces set the pangram. declarations sorted, variables first
drawing
the nodes are shapes and points — pen, pencil, text, an infinite canvas, snapping to every sibling. a transform bakes back into the shape's own numbers
type
the nodes are glyphs. a .glyphs source is a type lab — metrics, kerning on the baseline, live masters and instances, unicode coverage, a ~50-check audit graded with the fix, variable ttf and woff2 export
data
the nodes are keys and rows — json is a document, csv is a table, xlsx and sqlite open, read
code
always a diff — your working copy against HEAD, scrolled to the first change. you never look at code without seeing what you changed

7   move

home, project, file, node — it's one tree. the breadcrumb is where you are — click back through it. esc steps out one level. walk between files in a folder.

⌘ z undoes anything, anywhere — text, drawings, the conversation. ⌘ ⇧ z redoes.

every key
any letter
— any character, really — starts a prompt, seeded with what you typed. hold control to speak
enter
think · ⌘ enter makes the text a .md file, named from its first line
space
back into the chat you were just in. in a player, play/pause
esc
close the chat; again, step out one level; again, home
walk between files. in a player, ∓5s
the left edge
hover it — the panel: projects at home, structure in a file
“source”
hover it — the file's source slides out beside it, scrolling in step
a link
click once to select, again to follow — inside the project or out to the browser

8   share

make it together.

while you think, type a @name or an email. they join the chat and the project — you edit together, live, cursors and all. the bar where you talk to claude is the bar where you bring a person in.

not on bicycle yet? they get an email. when they sign up, they're already in. presence shows who's looking where; you watch each other work, in the same folder, at the same time.

who sees what
levels
edit or view. a viewer can talk; an editor can ask claude to change things. tab flips it as you invite
cursors
what they hover gets an outline in their color. their avatar rides their pointer — even inside a live page
presence
who's inside which file, on the card. who's in which project, on the home grid
chats
shared with the project — one room, many people, one claude. it stays quiet in a crowd unless you say “bike”
a push
lands in everyone's editor, live

9   publish

make a project public and it's a website — live at you.bicycle.computer. point your own domain at it. every push updates it.

projects start private. publishing is one toggle; an apex domain brings www. along for free.

domains & branches
a folder
one click on the card: git init, first commit, a repo, a remote, a push
free domain
anything.bicycle.computer — served the moment you claim it
your domain
point an A record at bicycle and it's live. take the last domain away and it's down
which branch
the site serves the publish branch — everyone can be working on another one
which folder
publish_dir — serve docs/, or the root
private
is about who can read the source. a private repo can have a public site
every push
refreshes it
your page
bicycle.computer/you — every project you've made, as it is

10   sync

you never save, never commit. every change is its own version, with a history you can walk back through. open the project on another machine and it's already there.

it's git underneath — but you never touch it. no add, no push, no conflicts to resolve. when someone you've shared with makes a change, it streams in live and everyone stays on the same main.

how it moves
writes
land instantly, then go out. a failed send stays queued and retries
commits
thirty seconds after you stop, claude reads the diff and groups it by intent, each with a real message
pushes
after every commit. rebases onto everyone else every three minutes, and the moment someone pushes
conflicts
resolved once, then replayed. what can't be resolved is left alone — never a broken tree
history
the panel: what's changed, what's unpushed, what's landed. click a commit to see its files
it's git
a real repo, a real remote. clone it, push to it, walk away with it. turn sync off and it's yours alone

one machine. one purpose.

coming soon.

a computer that does nothing but run bike. you sit down, you see your files, you work. invisible modality, made physical.

free for students.

the first web browser was also an editor, a collaborative space for everyone. the first NeXT Computer targeted education and gave us the World Wide Web. when you solve for education, you solve for humanity. that's where bike starts.

bike is free for every student and every teacher, software, AI, all of it. the work belongs to them.

bicycle.school

free while we're building.

download free forever no account needed. bring your own AI, we never charge for it. download xattr -dr com.apple.quarantine /Applications/Bike.app
sync & publish $5/month files sync and version across devices. share folders with anyone. publish any folder as a live site. sign up