LumiChats Offline(free)
Your AI, fully offline with Zero data collection & 100% free
284 followers
Your AI, fully offline with Zero data collection & 100% free
284 followers
Run powerful AI models entirely offline no internet, no GPU, no cloud. LumiChats Offline is a free, open-source desktop app built on GPT4All with full privacy by default. Supports Mistral, LLaMA, Qwen, DeepSeek and our own fine-tuned LumiChats models. Chat with your own PDFs and docs via LocalDocs. Works on Windows, Linux and macOS.
This is the 2nd launch from LumiChats Offline(free). View more
Lumichats(Free)
Launching today
70,000 people use LumiChats in a browser and kept asking for the one thing a browser cannot do: touch their files. So we built the desktop one. It runs commands on your machine, writes real documents, and you pay only for the work you run.
Free Options
Launch Team / Built With
LumiChats Offline(free)
Pay for what you run sounds obviously fairer than a subscription, and it has one nasty failure mode: people start rationing. The moment someone can feel the meter, they stop asking the second and third question, and those are usually the ones that get them the answer. Watch actions per session in week two against week one. If that drops, the pricing is teaching people to use it less, and "under a dollar for an afternoon" won't save you.
LumiChats Offline(free)
@asadmalik901 That's a really insightful point, Asad. It's something we've been thinking about as well. Our goal is to make costs predictable enough that people don't hesitate to use LumiChats, and we'll definitely be watching engagement patterns like actions per session. One thing we've tried to do is avoid making people feel like they're being charged for every tiny interaction—when you start a usage period, you're free to use it without constantly watching a meter. If we ever see pricing discouraging exploration, we'll iterate. Thanks for calling this out—it's genuinely valuable feedback. 🙌
Interesting angle — the terminal is doing more work than people realize, and it's not the typing.
When Claude Code generates something that doesn't compile, the terminal is where the loop closes: the agent sees the error, reads it, and retries. Take the terminal away and someone still has to close that loop. Does Lumichats surface the failure to the user, or does it self-correct silently before they ever see it?
I ask because in my experience that's where the whole "no-terminal" promise usually breaks: the moment a non-technical user is shown a stack trace, you've lost them — but if you hide it and retry blindly, you burn tokens and they wait without knowing why. Curious how you handled it.
LumiChats Offline(free)
@rodrigo_baigorria It self-corrects, and the user sees that it's correcting without being shown what broke. The raw error goes to the model verbatim; the user gets one line in a collapsed panel — expandable to the full stack trace. Not hidden, just demoted.
Blind retry is the trap, so it's bounded: if the model asks for the same thing that just failed the same way, the run stops and says so. And a run that produced no file and no answer is never reported as finished — "it ran without erroring" isn't "it worked".
Honestly, the failure we hit wasn't stack traces, it was silence. A model writing a long file sends it as one tool argument, so the busiest minutes had nothing to show — which reads as a hang. Still finishing that one.
@aditya_kumar_jha1 "Demoted, not hidden" is the right call — and "it ran without erroring isn't it worked" is the part most people skip entirely.
On the silence: I hit exactly the same wall and ended up splitting it in two calls. A cheap, fast one that only produces the plan — what it's about to build, in plain language — streamed token by token, and then the expensive one that actually writes the files. The narration fills the dead minutes with something true instead of a spinner, and it barely costs anything because you can run the planning call at low effort.
The other thing that saved me was a heartbeat every 15 seconds on the stream. Not for the user — for the infrastructure. My host was silently dropping long connections, and from the client side that is indistinguishable from a hang.
Congrats on the launch.
LumiChats Offline(free)
@rodrigo_baigorria The heartbeat one lands. I have the pessimistic half — the client calls a stream dead after 90s of silence, reset by every chunk. But that only bounds how long you wait for nothing; it can't tell you the connection is alive. Same road as you: a host holding a connection open, then five minutes later a terminated from the HTTP layer that nothing matched on. I'd filed it as a UI problem. It's an infrastructure one. Taking that.
The two-call split fixes something my answer doesn't. Reasoning does stream, so it isn't literally silent — but reasoning is the model talking to itself, and using it as narration means showing someone chatter never written for them. A cheap planning pass produces something authored for the reader. Different object. I'd watch for drift, since the writing pass can wander off the plan it just narrated — probably still worth it.
Thanks — these two are worth more than the congrats.
@aditya_kumar_jha1 Drift is real, and I don't think you can prevent it — but you can make it detectable. I treat the plan as a contract: pull the checkable claims out of it (which files it said it would create, which sections it said it would wire up) and assert them against the output afterward. If the writing pass wandered, the assertion fails — and that's a far better signal than the model's own report that it finished.
It gave me something I didn't expect, too: the failures turn into a corpus. Every time an assertion catches drift, that becomes a rule I feed into the next generation's prompt. The plan stops being narration and starts being a test.
Good luck today.
LumiChats Offline(free)
@tehreem_fatima5 That's a completely fair concern. We chose to launch before the code-signing certificate was ready because there was strong demand from early users, especially researchers and scientists who wanted the desktop version as soon as possible. An OV code-signing certificate is our top priority, and we're working to get it in place as soon as we can. We're also planning to open-source the codebase, because software that can run commands on your machine should be transparent and auditable. In the meantime, LumiChats is permission-first and always asks before making changes to your system.
The CPU only inference is the quietly underappreciated constraint here most offline AI projects quietly assume you have a CUDA capable GPU, so running on any modern laptop without that dependency
LumiChats Offline(free)
@mohammed_messeguem Thanks, Mohammed! That was a deliberate design goal. We wanted LumiChats to work on the hardware people already have, not just high-end GPU machines. If someone does have a GPU, they can use it, but CPU-only support was important so more people can run AI locally without extra requirements. 🙌
"A black window that expects you to already know the words" is exactly why terminal tools stay niche no matter how good they are.
LumiChats Offline(free)
@irahimiam Thanks, Arash! That line came from hearing the same frustration over and over. The goal with LumiChats is to make that same power accessible without requiring people to learn terminal commands first. Really appreciate you taking the time to read and comment! 🙌
What's the difference with Claude Cowork ?
LumiChats Offline(free)
@tacitefood Great question! Cowork is probably the closest comparison, and it's an excellent product. The main differences are that LumiChats lets you choose between running everything locally or using the cloud, supports 40+ models instead of locking you into one, and has flexible pay-as-you-go pricing with unlimited use during a day pass—no subscriptions or session limits. It's also designed to make powerful AI workflows accessible to non-developers through a simple desktop interface.