Changelog

What's new in each version. Every release is also on GitHub.

Lamp 0.35.0on GitHub

Share's main button is New Release now, with Copy as a small button beside the link. Once you've released, the window's main button is View, which opens the link's page.
Release Update puts an app on GitHub the first time too, and after that updates GitHub in the same press as the link.
Merged someone's changes into your app on GitHub? Bring In Changes brings them into your app before you release again, keeping your own.
The GitHub repositories Lamp makes are much smaller: they no longer carry a copy of the app file.
Commits Lamp makes to GitHub are signed the way your own git signs them.
When a change brings an error into the app, Lamp sees it and fixes it in the same turn.
A game no longer stays hidden behind the smoke when a change didn't touch its page.
Sharing an app with a file you locked in Finder works again.

Lamp 0.34.0on GitHub

Release Update replaces Update Link: Lamp writes a short "what's new" from your changes, which you can edit before it goes. It shows on the link's page and under What's New… in the app's menu.
Paste someone's shared link into the chat and ask for the part you like ("pull in the water from this one"): Lamp fetches their copy, brings that part into yours and notes where it came from.
Send Changes Back sends only what you changed, on top of the latest version of the original.
Share is always in the chat's toolbar now, next to ⋯.
Lamp calls what it makes an app, in plain words while you ask and while it works.
Messages sent in long chats go out right away again.

Lamp 0.33.0on GitHub

Share a link anyone can open in a browser: the game or app plays right on its page at lamp.dev, with who made it, and anyone with Lamp can make their own copy from it, with a change in mind if they like. The link carries the app's name, and Update Link keeps it current as you go.
Follow the copies you like and pull in what their makers did; Lamp puts the changes together for you.
Share from one place: the Share button shows the link with Copy, AirDrop, Messages, Mail and more, and Share Link has a window of its own.
New apps are web apps, so they open anywhere, and Put on GitHub gives a web app a page people can visit.
Open a plain website from GitHub and it opens as an app that keeps its layout.
Changes to games land much sooner: Lamp looks at the open game in under a second and only when it helps, and it answers your messages while it's still working on a change.
A game taking a change in shows one gentle sweep of color, not a run of them.
Unsaved chats and drafts are kept, and Lamp tells you if it couldn't save one.
Lamp no longer quits when a device on your network sends something it didn't expect.
Lamp has a new icon.

Lamp 0.32.0on GitHub

New starter: Chores, a to-do list you type into in plain words ("call mom friday 6pm"), with projects, labels and smart lists.
Give Lamp a picture or an icon file and ask for it to be the app's icon: it uses it as is.
The desk answers every click again, and opening an app brings it to the front with its chat.
Your devices are on the desk, where "More" shows every other one Lamp can find on your network.
Check for Updates… for a wish from GitHub is in its ⋯ menu on the desk, where Wish Info used to be.
The wand in an app always opens its chat, and a wish whose first naming didn't work gets its name at the next request.

Lamp 0.31.1on GitHub

Put on GitHub can show a picture of your wish in its README: the card shows the picture, so you can leave it out.
Games hold on to much less memory from one change to the next, so they slow down and stand still far less as you keep changing them.
Update from the Original, asked for while a change is under way, now waits for it to finish instead of holding Lamp still behind an alert.

Lamp 0.31.0on GitHub

Put a web game on GitHub with a page to play it: Put on GitHub now publishes the game's page alongside its code and gives you the link.
Share a wish that uses data with no stated license: Lamp warns you and lets you decide, and when sharing fails it says why.
Reload, in every app's menu (⌥⌘R), puts the latest change on screen.
Open and Play work while a change is being made: the app opens as it is and takes the change when it's done.
Changing a big game no longer freezes it: only the part of its world a change touches is built again, in the background while you keep playing, and the chat says when something waits for Reload.
Lamp checks a game in the window you have open, so changes to a game finish sooner.
A remixed app gets its own icon drawn, and the desk shows a picture of a game rather than its loading screen.
Long requests keep going: only a model running on your Mac pauses after 150 steps, and a conversation that grows too long is shortened without stopping the change.
Setup shows how far downloads have got, can try again, and explains connection problems plainly.
With a wish picked on the desk, Name This Version… and Copy Wish File act on it.
Games use the latest three.js.

Lamp 0.30.0on GitHub

A much smaller download: Lamp is about 70 MB instead of 264 MB. Starter apps are fetched the first time you open one, and what runs models on your Mac the first time you choose one.
Open an app someone sent you before setting anything up: its review comes first, and your first change asks for what it needs right there in its chat.
Open a link to a project on GitHub on a Mac without Apple's developer tools.
Games keep your place through a change: every new game is made that way, and a change that would start play over waits for Reload instead.
Phone controllers respond more reliably to each button press.
On the desk, Open is the first thing a wish offers, with Remix below it, and a spinner shows while a starter app is getting ready.
You can turn off the usage counts Lamp sends, in Settings → Memory.

Lamp 0.29.0on GitHub

A new look: Lamp is on paper with stripes, in light or dark to match your Mac. The desk is one list, your wishes on top and the starter apps below, in a section you can fold away. The Dock icon brings it back whenever it's hidden.
Remix changes a wish in place. Duplicate… makes a new copy, and Start Again from the Original starts its conversation over too.
Change a game while you play it: most changes go straight into the running game, without starting your level or your drive over.
One change reaches every screen a wish is on: open pages update at once, and Reload puts it everywhere.
Lamp keeps a wish's shared data, so a TV or tablet that opens on its own gets your family's calendar, shopping and photos without another screen open.
Phones as controllers: games on the Mac, an iPhone or iPad, a Samsung or LG TV and the Xbox let phones on your Wi‑Fi join as players.
Games can use free 3D models, art, sound effects and music, and be written in TypeScript.
The Xbox controller moves around TV apps and screens, and an app starts once it's really installed.
New starter: The Little House, a cozy room on a rainy night. New York offers a sports car, taxi fares, and playing as a monster.
A menu bar app tells you where it is when it opens, ⌘Q works in games, and a long-running wish no longer fails with a connection error.

Lamp 0.28.0on GitHub

Remix a game or an app straight from its page. Remix opens the untouched original on your desk, with your request waiting in its chat.
Make any project on GitHub into a Lamp app or game: paste its link and say what you want. Lamp keeps its credits and licences, and an app made from GitHub or opened from a wish there tells you when an update is available. You review it before your app changes.
Games aim to be fun from the first build, and "Make it a lot more fun" is one of the changes New York offers.
Home HQ listens: ask it something, or tell it to add an event or a chore.
A wish's chat stays with it when its app plays on another device, and Lamp offers its own panel when an app can't show the chat beside it.
Android: a phone or TV is checked as you choose it, an Android TV keeps its place in a wish, and setting one up over Wi‑Fi walks you through it.
Starters each have their own page on GitHub, with a picture and a way to try them.

Lamp 0.27.0on GitHub

The desk shows your devices on a shelf between your wishes and the box where you wish.
Remix with git underneath:
A wish remembers exactly what it was made from.
Update from GitHub brings in the latest of the wish it came from, merging it with your own changes.
Send Changes Back offers yours to it.
Starter wishes live on GitHub. A starter you've changed can take its starter's updates and send your changes back, and New York has the latest Slop New York.
Share a screen or a web app as a file, put it on GitHub, or make it a starter, as you can a game.
A game opened again after a change starts where you were, without its title screen in the way.
Open Settings works from the chat beside an app, and comes up in front of it.
The Chrome sidebar is gone.

Lamp 0.26.0on GitHub

Games change while you play them. New pictures, models and sounds appear in place, a change to the game's code puts you back where you were (the level, your position, the camera, the score), and a change made during a match waits for a pause or for you to press Reload. On an iPhone, Android, a TV or an Xbox, the game picks up where you left off after Lamp installs the change.
Games and screens open on the Mac in about a second, and no longer need Apple's developer tools unless they read your own things like your calendar or photos.
Open a wish from GitHub: File → Open from GitHub… takes a repository's address, and the wish's credits say where it came from.
Adding a starter wish opens it.
Your Devices tells the devices you've set up apart from ones Lamp only found on your network, which may be a neighbor's, and every found device offers Set Up….
A game made inside a wish has the wish's chat beside it.

Lamp 0.25.0on GitHub

Apps build again with Xcode 26. Since 0.24.0 they only built with the Xcode 27 preview.
Two new starter wishes. Home HQ is a family dashboard for the kitchen: calendar, chores, shopping and photos, on a tablet, a TV or an unlocked photo frame. It's based on Wes Bos's photo-frame-dashboard. Universal Remote controls whatever your house has from your Mac or phone.
Your Devices finds everything on your home network, sorted by what Lamp can do with it. Lamp asks about the local network only once you do something with a device, and the agent asks before it changes one.
Do It for Me sets up developer mode on a Roku or an LG TV. A Roku app can now be one of a wish's apps, and Lamp says plainly what a Roku can't run.
Games:
2D games, made with Phaser so they go everywhere a game goes.
Real physics in 3D games.
Buttons named the way your controller, keyboard or touch screen names them.
Smoother frame rates on slower devices.
Old Xbox games now live on your Mac too, with the Xbox as one of their places, and Try On always offers another device.
One app can be open on several devices in a wish, and lists like a calendar or chores stay the same on all of them, and between a wish's different apps.
Share a 3D game as a file, publish it as a page anyone can play (experimental), or put a wish on GitHub. A wish carries where it came from, shown in its info and About window. Lamp checks licences and keys before anything is shared, and marks pictures made with AI.
A Share Link can carry the wish itself.
Wish chats are listed in the Window and Dock menus, wishes open into their chat from the desk, and an app on a Mac without Lamp has a way back to it.
Apps that use AI just after they open wait for Lamp to find Claude Code, instead of asking for an OpenRouter key.

Lamp 0.24.0on GitHub

Make apps for Google TV, Android TV and Fire TV: wish for one, try it in a TV emulator on your Mac, and put it on your own TV over Wi‑Fi with Connect a TV Over Wi‑Fi… under Try On.
Connect an Android phone over Wi‑Fi the same way, with the pairing code it shows.

Lamp 0.23.0on GitHub

Your iPhone and Mac apps can control your Roku: a button that opens Netflix, YouTube or a show, the remote's keys, typing into its search, and on a Roku TV its power, volume and inputs. Nothing goes on the Roku; turn on Settings → System → Advanced system settings → Control by mobile apps.
Roku apps have their icon and splash screen, close when you press Stop, and come off the Roku when you delete the wish.
Lamp types into a Roku app's keyboard and can press every button on the remote when it tries an app.
Setting up a Roku is quicker: press Continue and Lamp presses the remote's keys that turn on developer mode.
A setup step that has worked on a real device says Worked before.

Lamp 0.22.0on GitHub

Put your iPhone apps on your phone with a free Apple account, no paid membership needed. Apple lets such an app open for seven days; Lamp now puts it back every day by itself, so it keeps opening.
Check "Keep apps on your phones opening" in Settings → Building (or press Keep It Opening in the chat) and Lamp opens out of sight when you log in and stays running with its window closed, so this happens without you.
If an app has stopped opening anyway, Lamp says so in its chat with Retry, under your phone in Settings and in Try On.
A free account takes three apps per phone: before a fourth, Lamp asks which of its apps to take off.
Lamp tells you, and the agent, what a free account can't do (iCloud, NFC, Siri, Apple's weather, Time Sensitive notifications) before anything is built, and a newly added free account gets the steps to finish setting it up.
Move to a paid membership whenever you like: if your team changes, Lamp replaces the old copy on your phone.
A file dropped on the desk's bar is attached instead of typed.

Lamp 0.21.1on GitHub

A game for an Xbox Series X or S is made for that console, which draws far more than an Xbox One, and Lamp calls your Xbox by its real model.
Pressing Stop on a TV or Xbox app keeps its chat on screen, and Lamp no longer quits when its window was closed.
A new wish's chat opens on the screen you're using.
Lamp no longer asks to look on your local network at its first launch.

Lamp 0.21.0on GitHub

Attach files when you wish for something new: press + in the desk's bar or drop files on it.
A game is one of its wish's apps everywhere it's played, on your Mac, iPhone, iPad, Android phone or Xbox: it sends messages, values and files to the wish's other apps, like any of them. So is a screen.
A new game shows the same card a new app does while Lamp makes it, instead of a ball on a floor.
A new wish's first message no longer shows twice in its chat.
The chat beside an app is named after the app, and a turn's cost says when it was spent on pictures.

Lamp 0.20.0on GitHub

A wish's chat is always beside whatever shows it: beside the app on your Mac, beside the simulator for an iPhone app, or in a window of its own when nothing on this Mac shows it, such as an app on your TV or Xbox. Lamp's window is now just your wishes.
Games are a kind of wish of their own, at home on your Mac, and the same game can go on your iPhone, iPad, Android phone or Xbox when you ask. A screen, a page shown full screen, goes on your TV, iPad or Xbox the same way, and apps for Apple TV and Vision Pro open there.
Any app of a wish can be added, replaced or taken away, the first one included, and the wish keeps its name, chat and history.
A wish's apps talk straight to each other on your home network, so they keep working with Lamp closed. They share values and files, say why another app isn't there, and everything they send each other is sealed.
iPhone apps made by an older Lamp are updated when you open them from Lamp.
More changes go into an open app without a reload.
Xbox web games install as games, which gives them more of the console.
New York's Manhattan sits on its real hills, and keys no longer beep in it.
Sharing from the chat beside an app no longer deletes a file another share is still sending.

Lamp 0.19.0on GitHub

One wish can now be several apps that work together, with one chat: a TV app with the iPhone app that controls it, or a Mac, iPhone, Android and TV app side by side. A wish that could be for more than one device, and doesn't say which, asks you first, and "make it work on my TV too" adds an app without rewriting the one you have.
The apps of a wish see each other and send each other messages, and phones talk straight to the TV, so a phone can hand the TV a game, a photo or a song.
Share a whole wish: every app in it goes in the file, TV apps included.
A new app's first build reads as chapters in the chat: each part of the plan, ticked as it's done, with what was said and done under it, and Lamp's question where it was asked.
Xbox games have sound, and Xbox apps play sound from the start instead of after the first button press.
A new starter wish, New York: Mr.doob's Slop New York, all of Manhattan to explore on foot, by car, by bike or by helicopter. It takes Drive Anywhere's place on new desks; add it from Starter wishes at the end of the desk.
A wish made by a newer Lamp is left as it is, shown faded on the desk, instead of being opened as an empty one.

Lamp 0.18.11on GitHub

Share a wish as a link: Share Link… shows you exactly what will be public, then copies a lamp.dev link with a preview card. Whoever opens it gets the wish in Lamp, ready to make their own, or a page to download Lamp.
Xbox games now run as games, not apps, so the console gives them five times the memory and its whole graphics chip: a test game went from 30 to 60 frames a second.
While Lamp tries an app, its glow, pill and pointer stay with that app's window instead of floating over everything else you're doing.
Each stretch of the agent's steps reliably gets its one-line title.

Lamp 0.18.10on GitHub

Xbox apps and games can make your controller rumble, and the rumble comes on the controller that's playing.

Lamp 0.18.9on GitHub

Xbox apps and games now get three.js for 3D, which the agent writes more reliably and which makes each app about half the size.
A new starter wish, Transcriber, transcribes calls with both sides and their sound; add it from Starter wishes at the end of the desk. New desks also get a livelier Buzzer Beater, with a denser scoreboard and team logos.

Lamp 0.18.8on GitHub

Xbox apps and games now run in the console's modern web engine instead of its old one: the same 3D scene went from about 21 to about 57 frames a second, with WebGL 2 and today's JavaScript.
A device Lamp can't find on this network, because it's off or at another home, says "Not on this network" instead of Ready.
A new starter wish, Site-to-App, turns websites without a Mac app into apps of their own, and Disk Map now shows what fills your disk as a sunburst you can click through.
While you write a wish, the desk's icons step back behind the bar.

Lamp 0.18.7on GitHub

Setting up a device no longer crashes Lamp: every setup window now opens sized to fit and stays up.
Wish for a big, fast 3D game on your Xbox and Lamp makes it as a native game that uses the console's full power. The agent plays it on your Mac as it builds, then puts it on your Xbox. The tools for it are a one-time download of about 2 GB, asked for only when you wish for such a game; other Xbox apps and games need nothing extra.
Your Xbox stays connected after Device Portal restarts, instead of asking you to reconnect it each time.
Deleting a wish made for a device also takes its app off that device.

Lamp 0.18.6on GitHub

Make 3D games for your Xbox: Lamp comes with a 3D engine for them, the agent tries each game in a window on your Mac as it builds, and the game reads your controller's sticks and triggers.
A device that was reset or had its developer mode turned on again can be reconnected, and Settings → Your Devices lets you reconnect or forget any device Lamp set up.
A TV app can have a page for your phone, as a controller, a buzzer or a second screen, served by Lamp over your home Wi‑Fi while the app runs.

Lamp 0.18.5on GitHub

Settings no longer crashes when you set up a device with a long list of devices: the window stays on your screen as it grows.
The agent's steps fold into a line saying what they did as soon as it moves on, and a step that failed says so.
When building for a TV, the agent knows whether the app is in the preview on your Mac or on the TV itself.

Lamp 0.18.4on GitHub

A new starter, Disk Map: see where your disk space goes as a map that fills in while it measures, and clear out what you don't need. It doesn't ask for your private folders until you choose to measure them.
On macOS 27, Lamp's taps and drags when it tries your app reach every button and gesture again.
TV apps can load their own files in the preview, pictures and sounds included, and the agent knows the preview is on your Mac, not your TV.

Lamp 0.18.3on GitHub

A turn built with your Claude subscription no longer shows a dollar amount: that was what it would have cost at API prices, not money spent. Costs show only for what you pay for through OpenRouter.
When the agent tries your app while a change is going in, it reads what's on screen again instead of finding nothing.

Lamp 0.18.2on GitHub

Switching between Claude, ChatGPT and OpenRouter keeps the conversation: the one you switch to knows what was said before.
A new wish knows which devices you have: "make tetris on my TV" is made for the TV that's actually on your network, and apps for devices like a Roku get Lamp's icon on the device.
An Android app opens where you were after a change, instead of on its first screen.
Drive Anywhere loads the streets ahead of the car, two pieces at a time, and says when the map is still coming.
LG TVs take apps more reliably, and closing the TV preview stops the app in it.
On macOS 27, Lamp's clicks when it tries your app land again.
More changes go into an open app without restarting it, including ones to how an app loads what it saved.

Lamp 0.18.1on GitHub

A new starter, Drive Anywhere: a driving game on real streets anywhere in the world, built from the map as you drive. It opens in San Francisco, and Travel takes you anywhere you can search for, with the traffic, people, shops, trains and hills that are really there. It needs macOS 15, so it's offered once your Mac has it.
Settings → Building → Your Devices ends in one Add a New Device… button, which shows how to connect an iPhone or iPad, an Android phone or tablet, or a TV, and lists the devices Lamp finds on your network while it looks.
LG TVs are found reliably, whichever of their services answers Lamp first.

Lamp 0.18.0on GitHub

Lamp makes apps for more than the Mac and the iPhone. Wish for an Android app and it's written in Kotlin, built, and opened in the Android emulator or on your own phone or tablet, with Lamp's building blocks for AI, saving and pictures; Android wishes can be shared as files too. Wish for a TV app and Lamp finds your Samsung or LG TV on the network, walks you through setting it up, tries the app in a preview on your Mac, and puts it on the TV itself. A Roku, or an Xbox in Developer Mode, gets its app the same way.
Settings → Building lists every device Lamp knows, by its exact model and whether it's ready, with the one next step for each; Try On lists the same phones. The agent is told which device a wish is for, so it builds for the screen and features that device has. A device Lamp has no kit for can be described to it and set up in one window.
When a change needs a Reload and you've stepped away from your Mac, Lamp presses it for you and the agent goes on; while you're there, Reload stays yours.
The agent now shows a new look in the open app while it's still working, and keeps the changes that need a Reload for last, so there's one Reload at the end instead of several.
Each fold of a finished turn says what it did and how long it took. A new app's build card opens to the steps so far, and the chat shows messages, steps and Reload in the order they happened.
A starter added back opens as soon as it's ready, even while the others are still being prepared.
Lamp finds Codex where the ChatGPT app now keeps it, and apps' quick decisions go to the newest small models.
Far more changes go into an open app without restarting it: new settings, bindings and environment values in a view, new properties in a saved struct, parameters a parent passes, and generic calls; a crash in a live change is caught and said in a sentence.

Lamp 0.17.0on GitHub

Each change the agent makes goes into the open app as soon as it's saved, so you watch the app change while it works. While a change is built, a soft smoke rises along the app's edges, and it whooshes away as the change goes in.
When the agent tries your app, you see it: its cursor moves to each spot with a word on what it's doing, and Stop hands the app straight back to you.
Setup and Settings offer four ways to build and to answer inside apps: Claude, ChatGPT, OpenRouter, and AI that runs on your Mac.
New starters: Buzzer Beater tells you when a live game gets close, wild or historic, and opens it where you can watch; Fireside and Local Crossings, a daily crossword made from the map around you, join them. Wedding Words is dressed like the invitations. Wishes you already have stay as they are.
The chat beside an app answers at once when you press Return, a menu bar app's panel keeps Lamp's wand beside its own buttons, and a Reload pressed while the agent works says it'll go in when the request is done.
Far more changes go into an open app without restarting it, and the review before opening a shared wish puts what to weigh first.

Lamp 0.16.0on GitHub

A new app opens beside its chat as soon as it's started and takes shape there in passes, the layout first, so you watch it being built instead of waiting for the end.
While a change is built, the open app glows softly at its edges, and a band of light crosses it as the change goes in. Changes go in faster, and an app that has to restart comes back sooner.
Lamp asks before restarting an app you have open: a Reload button in its title bar and in the chat puts the change in when you're ready.
The agent describes each step in its own words, and tells you what you can see now rather than what it wrote.
Drag wishes on the desk into any order, or onto the trash to delete them. A wish being built glows and says what it's doing under its name.
Hot Shelf is a lit studio shelf of real bottles. A starter's suggested changes now show the first time you open it, even after an update.
Approving the agent's commands takes about half the time, and the approval card puts the decision first.
More changes go into an open app without restarting it, and the ones that can't say why in plainer words.

Lamp 0.15.1on GitHub

A new case added to an enum goes into the open app more reliably: everything that reads the enum, including printing and saving, sees the new case, lists built from it are built again, and a change that code still running couldn't take reopens the app with a sentence saying why.
More from Lamp's list can be read on a Mac in dark mode, and the wand's flame shows on its blue glass.

Lamp 0.15.0on GitHub

Far more changes go into an open app without restarting it: a new method, computed property or stored property, a new case in an enum, a new default for an argument, a changed constant, a changed typealias, and what an extension adds from Objective-C. When a change can't go in that way, the chat says why in a sentence and the app shows a Reload button where it was, which puts the change in when you're ready; Undo, a restore and Rebuild & Open wait for it the same way.
Before a change goes into an app, Lamp keeps a copy of the app's data from just before it, so a change that spoils what the app saved can be put right.
Every app Lamp builds is drawn with Liquid Glass on macOS Tahoe, and the Reload button is glass too.
The chat draws the agent's tables, headings, lists, code blocks and quotes, and its text can be selected.
While the agent works, its steps are one line that says what it's doing now and opens to the rest, in Lamp's window and beside the app; what it writes on the way stays as a message. A build that runs long says so, and the agent names each command in its own words.
Approvals ask only for what reaches beyond the app: a command that works on the app itself, its files, builds and tests, runs without a card.

Lamp 0.14.0on GitHub

Change an app while you use it: the wand in its title bar opens its chat beside the window, and most changes go into the open app without it restarting, so what you were looking at stays put.
Point at part of an app, a button or a spot in a game, and it goes into your message as a picture.
Lamp opens on your wishes, and starts from what would make your day easier or more fun rather than from an app. A vague wish gets a good first attempt instead of a round of questions.
No more choosing Mac or iPhone: Lamp works out where a wish belongs. An app can be for the Mac and the iPhone at once, with iCloud keeping its data the same on every device.
iPhone apps can have home screen widgets, Live Activities and an Apple Watch app with complications, and keep working while they're closed.
Mac widgets' buttons work. Apps' actions show up in Siri, Shortcuts and Spotlight, apps can take things in from the Share menu, and every Mac app has File ▸ Share….
New building blocks: Apple Health, Photos, location, weather, music, the home, 3D scenes and maps. Apps connect to Notion, Linear, Todoist, Jira, monday.com, Home Assistant and more, signing in through the service itself.
Send Now hands waiting messages to the agent while it works, and Undo Last Change sits under the latest change.
Safer builds: they run in the app's own sandbox, and the agent's commands can't change your Applications folder, Homebrew or Xcode.
A rebuild waits while an app asks about unsaved work, and leaves it open if you say so. Rebuilding no longer asks for your keychain password, and deleting an app takes its data to the Trash too.

Lamp 0.13.0on GitHub

Building with your Claude or ChatGPT subscription no longer needs their apps or a command-line install: choose the agent and Lamp fetches its own copy, checked against the maker's signature, and keeps it up to date. A Claude Code or Codex already on your Mac is used as it is, with its sign-in.
The welcome asks what you wish your Mac did, and a wish written on lamp.dev arrives in Lamp without pasting. The starter ideas are real situations instead of app categories.
Duplicate an app to try a variation: the copy has the same code, history and icon on a new color, with an empty chat and its own data.
Your apps appear in Finder's Applications folder, and they open the files they're for: drop a file on an app's icon, or choose it under Open With.
When an app uses your other apps, you can watch it happen: a glow follows the window in use and a cursor shows each step, with approval beside the action and a Stop button. It's on by default with a Claude Code or ChatGPT sign-in or an OpenRouter key.
Permission screens have one place to drag the app from, and Open System Settings always brings the panel back.
The build card no longer says Ready over an app that couldn't be installed or opened.

Lamp 0.12.0on GitHub

Mac apps can have a desktop widget. Ask for one and the agent builds it into the app; add it from the desktop's Edit Widgets as you would any other.
New apps look like their kind. Before writing a line, the agent decides whether it's making a tool, a companion, a collection, a dashboard, a canvas, a utility or a game, and designs for that: a water reminder no longer comes out looking like a database.
The agent can paint pictures into an app, in the same style as its icon, and sees what it painted. What it costs counts towards the app, like the icon.
Lamp remembers. Its notes about you and about each app are on for everyone now, with the switch in Settings → Memory; it was the last experiment, so the Experimental tab is gone until the next one.
Fewer approval cards: a command that steps into one of the app's own folders and back isn't treated as leaving it, Lamp's own git work runs under the same sandbox as the agent's, and Claude Code reads its own saved output without asking.
Built apps are signed with Lamp's certificate on macOS 26 as well, so macOS keeps an app's permissions across changes; an app that moves from an ad hoc signature to Lamp's is told its permissions will be asked for once more.
A shared Mac app arrives with a note on how to open it and a description written for the person receiving it, and the review of a shared app no longer passes one it only partly read.
The App menu has one New Icon, drawn by whatever Settings says draws icons, and a failed icon says in plain words what went wrong.

Lamp 0.11.1on GitHub

Before an app goes on your own iPhone or iPad, Lamp checks that an Apple Account is signed in to Xcode and that your team is chosen, and tells you what's missing; one signed-in team is chosen for you. Help and the setup window say up front that a free Apple Account is enough.
Lamp works with Xcode 27, which shows simulators in Device Hub rather than the Simulator app: the setup check looks for either, and the agent's looks and taps find the iPhone's screen there too.
When an app is ready on the simulator, the simulator comes to the front.
Looking at an iPhone app, the agent also reads the screen as text beside its picture: every control and piece of text, what it holds and where to tap it, so small print and switch states aren't guesses.

Lamp 0.11.0on GitHub

The agent's shell commands run confined to the app: its folder, the system and developer tools, caches, temporary folders and the network, and nothing else on your Mac. A command that reaches elsewhere is simply refused by macOS, so Lamp no longer has to read commands to guess where they look, and the approval card is about what a command does. For anything outside, the agent uses its file tools, which ask you. With Codex, the whole of Codex runs confined that way.
iPhone and iPad apps are for everyone, no longer an experiment. Choose Mac, iPhone or iPad when you start an app, your very first one included, and the starter ideas follow what you chose. Lamp tries the app in a simulator on your Mac and, with Xcode and your Apple Account, puts it on your own iPhone or iPad.
The Apple team that signs apps for your phone is now in Settings → Building, and the models an app uses on your phone away from your Mac are in Settings → Apps. Both appear once you have an iPhone or iPad app.
Help has a new iPhone and iPad Apps section.

Lamp 0.10.8on GitHub

One answer to what answers your apps. Lamp works out, in one place, what handles an app's text, decisions and pictures, here and away on a phone, and how well. When an app needs something nothing here can do, a card in its chat offers the ways to set it up: a key typed in place, a download, a sign-in, or Image Playground for the icon. Settings → AI Providers shows what answers your apps, and the agent is told what the app has when it finishes a request.
Settings, tidied: Experimental is its own tab (Remember how I like things, and Build iOS apps with the Apple team, the away-from-this-Mac models and the setup check under it); Providers is AI Providers; menus list only what works now, with Not Ready beside a choice that can't be used.
Shared apps: the review shows the app's own icon and description; opening one you already have offers Update or Keep Both; one opened during setup or the welcome is kept, builds with its progress shown, and its review opens once setup is done.
The chat stays where you scrolled while the agent works, and follows the end again when you scroll back down or send a message.
Stop pressed while sign-ins are being checked keeps the agent from starting; a sign-in Lamp last found signed out is checked again before it's used.

Lamp 0.10.7on GitHub

The Keychain prompt at launch is gone for good: a key item that another tool put there can't be replaced by Lamp, so Lamp keeps that key in its own file (readable by your account only) and stops asking the Keychain for it.
Running an iPhone or iPad app no longer flashes the setup window open and shut: it shows only when a check takes a while.
A detail line's Show Full Output appears only when there's more to show.

Lamp 0.10.6on GitHub

What you attach in the chat stays on your Mac. An app's own files (a logo, a data file) live in its new Assets folder, the only folder bundled inside the app and shared with it; the agent copies an attachment there when the app should use it. Apps that already use an attachment get it copied over at their next build.
Making an iPhone or iPad app no longer crashes Lamp when the setup window appears.
The Keychain stops asking for Lamp's key at every launch: a key item that was put there by another tool is made Lamp's own after the first read.
A picture picked in Image Playground shows on the app in the chat at once, with a word that it goes on the app when the current turn ends.
A long chat shows its end first, and earlier messages come in as you scroll up to them.

Lamp 0.10.5on GitHub

Pictures no longer fall back to a ChatGPT Codex sign-in that happens to be on the Mac: Codex draws them only when it's what builds your apps or answers inside them. Otherwise, with no OpenRouter key and no picture model on this Mac, Lamp asks for one.
A chat can no longer leave Lamp stuck during a turn: every row shown is laid out, and a long chat shows its end first, with earlier messages a scroll away.
An app's icon artwork shows in the chat the moment it's picked, rather than at the end of the build.
Making a new app while an earlier new app was still working sent the message to the earlier app. Each app now has its own identity, kept through renames, so a fresh app's first message is its own.

Lamp 0.10.4on GitHub

Lamp remembers, as an experiment you switch on in Settings → Building: it keeps short notes on how you like things, so a new app starts out in your style, and on what you decided about each app and what you turned down, so it isn't offered again. The notes carry over when you switch the agent or model, and the AI opens them only when a request needs them. A Memory tab lists them, to read, change or clear.
When a key or sign-in is refused, or an account is out of credit, Lamp names the one that was used. It used to name whatever builds your apps, so an OpenRouter key that didn't work could be reported as a problem with ChatGPT Codex or Claude Code.
An app's icon can be made in Image Playground, on a Mac that has it: from the app's right-click menu, and offered when nothing else can draw.
Settings checks an OpenRouter key with OpenRouter before saving it, so a mistyped key is caught at once rather than failing later as a build or a picture. When OpenRouter can't be reached, you can save anyway.
Settings → Experimental: the iPhone & iPad setup check sits under its notes.

Lamp 0.10.3on GitHub

A new app's first build ends with the app ready for you: the agent looks once to be sure it opens, then asks whether you'd like it to test the app or change something first, instead of clicking around in it while you're trying it. For later changes it still tries them out before saying they work.
With a model on this Mac chosen for text, Lamp's own quick calls (an app's name and parts, the suggested next message, version titles) use it too, rather than going to OpenRouter.

Lamp 0.10.2on GitHub

Pictures are made with Nano Banana 2 again unless you pick another: Nano Banana 2.1 stays on the list, but its provider has been turning requests away.

Lamp 0.10.1on GitHub

No more Keychain password prompts: a key that was put in the Keychain by something other than Lamp made macOS ask for your login password at every read. Lamp now makes such a key its own after the first read, and reads keys once at launch, in the background, rather than while drawing a view; that also ends a crash when the prompt appeared as an app was being created.
Attaching files: the chat waits for the file picker to close before updating the attachments.

Lamp 0.10.0on GitHub

New apps start by choosing Mac, iPhone or iPad (with iOS apps on). Apps on your own iPhone or iPad work away from your Mac: while the Mac is reachable their AI goes through Lamp as before, and elsewhere they use your OpenRouter key themselves, kept in the phone's Keychain since they last saw Lamp. Settings → Apps has "iOS apps away from this Mac": the OpenRouter models a phone app uses for text, pictures and decisions when it can't reach the Mac, and an app's own panel has the same choices.
Putting an app on a phone says what's happening and what went wrong: it waits for the phone to confirm the launch (quickly now), explains install failures, and offers Retry; the iPhone setup in Settings shows the missing step and its next action.
Settings is reorganized. Providers shows what's on this Mac (Native Mac AI, Ollama, LM Studio, and your Claude Code and Codex sign-ins) apart from the providers you've added a key for, and says on each row what it's doing. Building has one Text generation menu, the models under what runs them (Claude Code, Codex, OpenRouter, a model on this Mac…), and its own Image generation choice for icon artwork. Apps has Text generation (every way an app's AI can be answered, by name), Image generation for pictures inside apps, and the decision model. Wherever something needs an OpenRouter key, an Add a Key… button sits at the right, and the notes say plainly what happens without one.
Decisions can be made on this Mac: H2O Lightning 4B, a free 2.5 GB decision model about as good as Jev, downloaded from Settings → Apps and run privately. OpenAI's Decisions API (Luna) is a choice too, with an OpenAI key, as is answering by text through whatever answers your apps. Jev preview is gone.
Pictures are made with Nano Banana 2.1, Google's newest image model, unless you pick another.
The welcome's agent step: picking Claude Code or ChatGPT is the choice; only a missing app or sign-in is asked for.
The agent writes in the language your Mac is set to, and so do the apps it makes.
The build card shows progress while the agent thinks, before its plan, and what's being worked on.

Lamp 0.9.3on GitHub

Report a bug from Help: Lamp gathers what happened, shows you the report to check, and sends it through lamp.dev.
The build script and package file of every app are Lamp's own again at each build, so nothing the agent writes into them can run around your approval.
Opening a shared app: the check no longer warns about Lamp's own building blocks, and says which of your data an app hands to the AI.

Lamp 0.9.2on GitHub

Apps can use your other apps whatever builds them: with a local model or your Claude Code or Codex sign-in as well as with an OpenRouter key. The person still approves every click and keystroke.
With the ChatGPT app's Computer Use installed, that's what does the looking and clicking: real clicks and drags in the background, better reading of what's on screen, and nothing to install. CuaDriver stays as the fallback, and a switch in Settings → Apps chooses.
The key Lamp hands its built-in agent is given out only to this Mac again.

Lamp 0.9.1on GitHub

iPhone and iPad apps use more of the phone: the agent knows about the motion sensors, the camera and scanning, location, haptics, Face ID, Bluetooth, nearby phones, Health, NFC, Siri and Shortcuts, AR and music, and asks for each one properly. Apps that need Health, NFC, Siri or work in the background are signed for it. The agent says which parts need your phone rather than the simulator.

Lamp 0.9.0on GitHub

Your iPhone or iPad apps on your own phone: with the new switch in Settings → Building → Experimental and your Apple account signed in to Xcode, plug your phone in: Try On pairs it with your Mac and lists it. Press Play and Lamp builds the app for your phone, signs it with your account and puts it there; its AI still goes through Lamp, over your Wi‑Fi.
A new welcome: the first screen and the new-app screen are quieter, with a short film of the lamp, and the ideas to start from are fewer and broader, drawing on the Mac's own apps. Once you have an app of your own, a new app's chat offers six fresh ideas each time.
Quick Look for the files in a chat: press Space on an attachment to see it.
Versions stays open after an Undo that takes an app back to empty.
Your keys live in the Keychain: a signed Lamp moves any left in its settings file there, and the agent no longer keeps a copy of its own.

Lamp 0.8.0on GitHub

iPhone and iPad apps, as an experiment you switch on in Settings → Building: build an app and try it in the iPhone or iPad simulator on your Mac (needs Xcode), choosing the device beside the Play button. The agent sees the screen after each change and taps, types, scrolls and swipes on it to try what it made (allow Lamp under Accessibility in System Settings when it asks). The apps get the same icon and the same building blocks as Mac apps: saved data that survives every change, AI and quick decisions, behavior written while the app runs, text read out of photos and documents, drops, calendar, reminders, contacts and notifications. Putting the app on a real iPhone comes later.
Change a message you already sent and send it again: a pencil on your message opens it for editing, and Escape puts it back.
A long chat opens on its latest messages.
Fewer needless approval cards: commands that only look like they reach outside the app's folder (such as sending output to nowhere, or writing a file inside the app) no longer ask.
Installing the local-model tools says what actually went wrong, and Settings gives the picture model's real size (about 1.3 GB).

Lamp 0.7.0on GitHub

Stop really stops: it ends everything the agent started, including a build in progress, and quitting Lamp while it's working asks first.
Deleting an app while it's being built no longer brings it back.
Claude Code asks before reading files outside an app's folder, like the other agents do, and follows the same "ask before running commands" setting. Every agent can now plan, delete files and work with an app's saved versions.
A shared app's review shows what the app can do as a list, like an app's permissions in System Settings, with anything sensitive marked; opening such an app takes a deliberate click.
Apps keep their saved data more reliably: a change that fails is undone as a whole, dates read back exactly, and a number that couldn't be saved before is kept now. A reply that quits the agent, a crash when recognizing text in a picture, and a crash when dropping several files at once are fixed.
Mail in your apps: message dates are right in every time zone, and accounts whose inbox has another name are included.
A question with a screenshot attached no longer rebuilds and relaunches the app, and an edit made while a build runs is picked up by the next one.
Icons: the finished artwork no longer arrives in the middle of a build.
Dictation no longer crashes on a Mac without a microphone; Copy App File has its ⇧⌘C shortcut in the Edit menu; app tiles and the welcome choices work from the keyboard.
Release notes are written by hand, so this is what you read here.

Lamp 0.6.3on GitHub

A new app shows "Describe an app…" until the first message.
A new app's icon artwork starts as soon as its icon is designed, so the first version opens with its icon.
Updates come from updates.lamp.dev.

Lamp 0.6.2on GitHub

An app whose last window was closed comes back with one when opened again.

Lamp 0.6.1on GitHub

"Ask before running commands" has a new default, Only when risky: routine, low-risk commands run without asking.

Lamp 0.6.0on GitHub

Forge is now Lamp. Existing apps, keys and settings move over on first launch.