lemonade-server.ai

Lemonade (lemonade-server.ai) installs as a local AI runtime that gives your machine a GUI, CLI, and API endpoints for text, image, speech, transcription, and embedding workloads. The site lists install paths for Windows, macOS, Ubuntu, Arch, Fedora, Debian, Docker, and Snap, and describes setup as "up and running in minutes." If your platform is on that list, you can install directly; if not, Docker or Snap is the fallback.

What you get after installing

Per the site, installation equips your computer with:

• An AI runtime — the engine that runs models locally
• A GUI — a graphical interface for chatting and managing models
• A CLI — command-line access for scripting and automation
• API endpoints — so your own apps can call the runtime

Lemonade is also described as "omni modal," meaning one install covers chat, vision, image generation, speech, transcription, and embeddings rather than separate tools per task.

Step 1: Pick your platform

Choose the native package for your OS if one exists — it's the shortest path. Use Docker or Snap when you want isolation, a reproducible environment, or your OS isn't directly listed.

Step 2: Install

Run the installer or package command for your platform. The site's Quick Start section is the authoritative reference for the exact command per OS, since package names and repositories change between releases.

Expected result: the runtime, GUI, CLI, and API endpoints are all present on your machine after one install step. You don't install these separately.

Step 3: Verify it's running

After install, confirm three things:

1. The GUI opens — launch it and check that it loads without errors.
2. The CLI responds — run a basic command to confirm the runtime is reachable.
3. The API answers — the site notes Lemonade works with hundreds of apps "thanks to the OpenAI API standard," so you can point any OpenAI-compatible client at your local endpoint to test it.

If all three work, your local AI stack is live.

Step 4: Connect an app or start building

You have three routes from here, all described on the site:

• Chat with Lemonade — use the built-in GUI directly
• Connect to agents — wire the runtime into agent frameworks
• Embed the SDK — add native support or an embedded copy of Lemonade inside your own application

For the third route, the site points to an Embeddable SDK, an API Reference, and the source on GitHub. Start with the API Reference if you're integrating an existing app; use the SDK if you're shipping Lemonade inside your own product.

Common sticking points

• Platform not listed natively. Fall back to Docker or Snap rather than trying to force a package built for another distro.
• Assuming cloud dependency. The site states Lemonade is local-first and routes to servers and cloud APIs only on demand — so a working install should function without a cloud account, though the site doesn't detail offline model management.
• Skipping the API test. Since OpenAI API compatibility is the main integration path, verifying the endpoint early saves debugging later.
• Version drift. The site says a new release ships every week. If a command from a tutorial fails, check the current release notes before assuming your setup is broken.

What "free" and "private" mean here

The site describes Lemonade as "free to use," "private by design," and "transparent, zero telemetry," with "no upsell," and says data stays where you put it. Those are the site's own claims about the product's design. The page evidence does not list pricing tiers, paid plans, or account requirements, so treat any specific cost or login expectation as unconfirmed until you check the current site.

Where to go next

• Quick Start — per-platform install commands
• API Reference — endpoint details for integration
• Embeddable SDK — for shipping Lemonade inside your app
• Source on GitHub — for build details and contribution
• Marketplace — apps already integrated with Lemonade

The project is community-steered through open working groups, so if your platform or use case isn't covered, the contribution guide and Discord are the places to ask.

You can cut most images to a fraction of their original file size without any visible quality loss by doing three things in the right order: resize the image to the dimensions it will actually display at, pick the right format for the content, then apply compression at a quality level that survives a side-by-side check. The single biggest mistake is skipping step one — an oversized image compressed at maximum quality is still far heavier than a correctly sized one.

Why file size and quality are a trade-off, not a fixed setting

Every compressed image is a negotiation between three variables: how many pixels you keep, how precisely each pixel is described, and how much the format is allowed to guess.

• Dimensions decide how many pixels exist at all. Halving width and height removes 75% of the pixel data before any compression happens.
• Quality level decides how aggressively the encoder discards detail it thinks you won't notice.
• Format decides the kind of discarding allowed — some formats throw away color precision, others only remove redundancy.

Because these interact, "quality 80" means something different on a 4000px photo than on a 600px thumbnail. Tune dimensions first, then quality.

Pick the format before you touch the quality slider

Practical rule: photos → JPEG or lossy WEBP; flat graphics and transparency → PNG or lossless WEBP; anything vector → SVG.

The four levers, in the order you should pull them

1. Resize to display size (biggest win, zero quality cost)

If your layout renders an image at 800px wide, serving a 2400px original wastes roughly 89% of the pixels. Resize to the largest size it will ever be displayed at, and add a 2× version only if you need retina sharpness.

2. Choose the format

Match the format to the content type using the table above. Converting a photographic PNG to JPEG or WEBP alone can shrink it by 80% or more.

3. Set the quality level

For JPEG and lossy WEBP, most photographs hold up well between quality 70 and 85. Below ~60, banding appears in skies and blur around text. Above ~90, file size climbs steeply for gains nobody can see.

4. Strip metadata

EXIF data, camera info, and embedded thumbnails can add tens of kilobytes. Remove them unless you specifically need copyright or orientation data — and note that stripping orientation can rotate an image, so verify after export.

When lossy compression is fine, and when it isn't

Lossy is acceptable when:

• The image is a photograph or has natural texture.
• It's decorative or below the fold.
• Slight softening won't be noticed at final display size.

Use lossless or vector instead when:

• The image contains text, UI elements, or thin lines (lossy creates ringing artifacts).
• It's a logo, icon, or diagram — SVG or PNG keeps edges clean.
• It will be edited again later; repeated lossy saves compound degradation.
• It's a screenshot of code or a chart where color accuracy matters.

Compressing vs. resizing: don't confuse them

Compressing reduces the bytes needed to describe the same pixels. Resizing reduces the number of pixels. They're independent, and resizing usually delivers the larger saving. A 3000×2000 photo at quality 95 might be 2 MB; the same photo resized to 1200×800 at quality 80 might be 180 KB. Doing only the quality reduction gets you maybe 40% off; doing both gets you over 90%.

A repeatable workflow

1. Determine the maximum display width in your layout (inspect the element or check your CSS).
2. Export at that width (plus a 2× variant if needed).
3. Convert to the right format — WEBP as a modern default, JPEG as a fallback, PNG/SVG for graphics.
4. Apply quality 75–85 for lossy formats and compare against the original.
5. Strip metadata and re-check orientation.
6. Verify before publishing (see below).
7. Serve the right file with srcset so small screens don't download the large variant.

How to verify quality before you publish

• View at 100% at final display size, not zoomed in — artifacts you can't see at real size don't matter.
• Toggle between original and compressed in a viewer or an online compressor's before/after preview.
• Check the worst-case areas: skies, smooth gradients, sharp edges, and any text.
• Compare file sizes and ask whether the extra kilobytes buy visible improvement. If not, go smaller.
• Test on a mid-range phone, where banding and blur are often more obvious than on a desktop monitor.

Common mistakes

• Compressing a full-resolution image and calling it optimized.
• Using PNG for photographs.
• Setting quality to 100 "to be safe" — it inflates size with no visible benefit.
• Re-saving a JPEG repeatedly, stacking artifacts each time.
• Forgetting that GIF animations are usually better as WEBP or video.
• Ignoring metadata, which can silently add weight.

Quick reference

The order matters more than any single setting: resize, then choose format, then tune quality, then strip metadata, then verify at real display size. Follow that sequence and you'll routinely land at 10–20% of the original file size with no quality your visitors can detect.

Lemonade is a local AI runtime that runs text, image, and speech models on your own computer instead of in the cloud. Installing it gives you an AI runtime plus a GUI, a CLI, and API endpoints, so you can chat with it directly, connect it to agents, or embed it in your own app. It is positioned as free to use, private by design, and zero-telemetry — data stays where you put it, with no upsell. If you want AI capabilities that don't depend on sending your data to a remote service, this is the category of tool to look at.

What Lemonade actually is

Lemonade is not a single chatbot or a hosted model. It is a runtime layer that sits on your machine and exposes AI capabilities through several interfaces:

• GUI — a graphical interface for chatting and interacting with models
• CLI — command-line access for scripting and automation
• API endpoints — programmatic access so other software can call the models

Because it implements the OpenAI API standard, it works out of the box with many existing apps and tools that already speak that format, not just ones built specifically for Lemonade.

What it can do

The platform is described as omni-modal, meaning a single install covers multiple capability types:

That breadth is the main practical difference from a narrow local model runner that only does text.

How it differs from typical cloud AI services

The distinction is where the computation and the data live:

• Local-first — models run on your hardware. Data stays where you put it, and the project states it has zero telemetry.
• No upsell — described as free to use, with no paid tier being pushed.
• Routes on demand — while local-first, it can also route to servers and cloud APIs when you need more capacity.
• Open and community-shaped — built in the open, with the roadmap steered by open working groups and contributions from a community.

For anyone whose main concern is keeping prompts, images, or audio off third-party servers, the local-first design is the reason to choose it over a cloud API.

Getting started

Installation is described as taking minutes and equips your computer with the runtime, GUI, CLI, and API endpoints. Supported platforms listed include:

• Windows
• macOS
• Ubuntu
• Debian
• Fedora
• Arch
• Docker
• Snap

From there, the documented paths are: chat with Lemonade directly, connect it to agents, or embed it into your own application. There is a Quick Start guide for adding native support or an embedded copy of Lemonade to an app, an Embeddable SDK, and an API reference.

Who it's for

• Developers who want to add chat, vision, image, speech, transcription, or embeddings to an app without building a model stack from scratch — the SDK and OpenAI-compatible API are the entry points.
• Privacy-conscious users who want AI features without data leaving their machine.
• Tinkerers and contributors who want to shape a local AI tool in public; the project points to Discord, GitHub, a contribution guide, and a philosophy page.

If you only need occasional text generation and don't care where it runs, a cloud service may be simpler. If you need multimodal AI that stays on your hardware and plugs into existing apps, Lemonade is built for exactly that.

Yes on both counts, based on how Lemonade describes itself. The project states that it is "free to use, shaped in public," that it runs with "transparent, zero telemetry," and that your "data stays where you put it." It also points to a public GitHub repository, a Discord community, and a contribution guide as evidence that it is built in the open. The rest of this page breaks down what each of those claims actually covers, so you can judge whether the privacy and openness match your needs.

What "private" means for Lemonade

The privacy claim rests on two ideas in the project's own wording:

• Zero telemetry — Lemonade says it collects no usage data about you. There is no analytics pipeline described in its materials.
• Data stays where you put it — processing happens locally on your machine rather than being shipped to a remote service by default.

The phrase "No upsell" also appears alongside the privacy description, meaning the project presents itself as not monetizing your usage through data or paid pressure.

The important caveat: local-first, not local-only

Lemonade describes itself as a "Scalable platform" that is "Local-first on all major platforms" but can also "Route to servers and cloud APIs on-demand."

That distinction matters for privacy. Local-first means the default path keeps your data on your own hardware. But if you configure it to route to a cloud API, that request leaves your machine and is governed by whatever provider you pointed it at. So the privacy guarantee is really about the default and about Lemonade itself not collecting data — not a promise that nothing ever leaves your computer under any configuration.

If your goal is strict privacy, keep it local and don't wire it to external endpoints.

What "open source" means for Lemonade

The openness claim is backed by concrete, checkable artifacts:

The project frames itself as "Truly open" — "Free to use, shaped in public, and built with a community that welcomes builders." The roadmap being steered by open working groups is the strongest structural signal here: it means direction-setting isn't controlled by a single closed team.

How to verify these claims yourself

Because the claims are about transparency, the right move is to check the primary sources rather than take the summary at face value:

1. Read the source — Open the GitHub repository linked from the site and look at how data handling is implemented. This is where "zero telemetry" can actually be confirmed or contradicted.
2. Check the contribution guide — See whether external contributions are genuinely accepted and how decisions get made.
3. Join or read the Discord — Observe how roadmap discussions happen and whether community input shapes releases.
4. Review the philosophy page — The site links to a "philosophy" document that states the project's principles in its own words.
5. Watch the release cadence — Lemonade says it ships "a new release every week," so recent activity is easy to confirm.

Who this fits

• If you want local, private AI with no telemetry — The stated design matches that goal, provided you keep routing local.
• If you want to inspect or contribute to the code — The GitHub repo, contribution guide, and open working groups give you a path in.
• If you need a guarantee that data never leaves your machine under any setting — Be careful: the on-demand cloud routing option means you must configure it to stay local to get that outcome.

The short version: Lemonade presents itself as free, private by design, and openly built, and it gives you the public artifacts to check those claims. The one condition to keep in mind is that "private" here means local-first by default, not local-only by force.

Lemonade works with existing apps because it exposes OpenAI-compatible API endpoints, so any tool already built for the OpenAI API can point at your local Lemonade instance instead. It also ships an embeddable SDK for adding Lemonade directly into your own application, and a Marketplace for finding apps that already integrate it. This applies if you want local, private inference behind apps you already use, or if you are building an app and want to bundle a local AI runtime.

The two integration paths

Lemonade supports two distinct ways to connect, and they serve different needs:

The site states Lemonade "is integrated in many apps and works out-of-box with hundreds more thanks to the OpenAI API standard." So the first path is mostly configuration, not development.

Using Lemonade behind apps you already have

The mechanism is straightforward: installation equips your computer with an AI runtime plus GUI, CLI, and API endpoints. Those endpoints follow the OpenAI API standard, so an app that lets you set a custom API base URL can be redirected to your local Lemonade server.

The practical steps:

1. Install Lemonade on your machine (Windows, macOS, Linux via Docker, Snap, Ubuntu, Arch, Fedora, or Debian).
2. Confirm the local API endpoints are running — installation provides them alongside the GUI and CLI.
3. In your target app, change the API base URL to your Lemonade endpoint and select a model.
4. Verify by sending a test request; the expected result is a response served locally rather than from a cloud provider.

The common sticking point is apps that hard-code a provider and don't expose a base URL setting. Those can't be redirected without the app itself adding support — check for a custom endpoint option before assuming compatibility.

Embedding Lemonade in your own app

If you're building rather than configuring, the Embeddable SDK is the route. The site describes it as letting you "add native support or an embedded copy of Lemonade in your app," and the Quick Start is framed around getting "up and running in minutes."

Supporting resources listed on the site:

• Embeddable SDK — for adding Lemonade into your app
• API Reference — for the endpoint surface
• Source on GitHub — for reading and contributing to the implementation

The SDK path matters when you don't want to depend on a separately installed runtime — you ship the capability with the app.

What your app gets

Integration isn't limited to chat. Lemonade is described as omni-modal: your app gets chat, vision, image, speech, transcription, and embeddings. That means a single integration can cover multiple feature types rather than wiring up separate services per modality.

Local-first, with optional routing

Lemonade is local-first on all major platforms, but it can "route to servers and cloud APIs on-demand." In practice this means you can keep inference on-device by default and fall back to remote capacity when you need it, without changing how your app calls the API.

Privacy and openness as integration factors

Two stated properties affect integration decisions:

• Fully private — transparent, zero telemetry, data stays where you put it, no upsell.
• Truly open — free to use, shaped in public, built with a community.

For apps handling sensitive data, the zero-telemetry and local-stay claims are the relevant ones. For teams that need to modify or audit the stack, the open-source engines and public roadmap working groups are the relevant ones.

Finding apps that already work

The Marketplace is the entry point for discovering apps with existing Lemonade integration. Beyond that, the OpenAI API standard is what extends compatibility to apps that were never built with Lemonade in mind — they work because they already target that API shape.

Choosing your path

• You use apps and want local inference behind them → rely on the OpenAI API standard; check each app for a configurable base URL.
• You're building an app and want AI bundled in → use the Embeddable SDK.
• You want to see what's already integrated → start with the Marketplace.
• You need to keep data on-device but occasionally scale → local-first with on-demand routing to servers and cloud APIs.

The deciding question is whether you control the app's code. If you do, the SDK gives you the tightest integration. If you don't, OpenAI API compatibility is your lever — and it only works when the app exposes an endpoint setting.