Caffeine generates apps on a specific, fixed technology stack. This is deliberate — the stack is chosen for security, data safety, and always-on availability on the Internet Computer. Understanding what's inside that stack (and what isn't) helps you know what to expect before you start building.
The technology stack
Every Caffeine app is built with:
- Frontend: React, TypeScript, Tailwind CSS, shadcn/ui components
- Backend: Motoko (a language designed for Internet Computer canisters)
- Data storage: Built into the app itself — no separate database
- Authentication: Internet Identity (passwordless, passkey-based)
- Payments: Stripe (via the payments integration)
- AI and LLM features: OpenAI (chatbot, embeddings, and other OpenAI-powered features via the OpenAI integration)
- File storage: Caffeine blob storage
- Animations: motion/react
- 3D graphics: Three.js and React Three Fiber
- Charts: Recharts
What is not supported
The following technologies and services are not part of the stack and cannot be used in Caffeine apps:
Backend languages and architecture: Rust, Python, Go, PHP, Ruby, Java, C#, serverless functions, microservices
Databases: PostgreSQL, MySQL, MongoDB, Redis, and other external databases — data storage is handled by the Internet Computer itself
Cloud providers: AWS, Google Cloud, Azure — apps run on the Internet Computer, not conventional cloud infrastructure
Frontend frameworks: Vue, Angular, Svelte, Next.js, Nuxt, SvelteKit, Gatsby, React Native, Flutter, Ionic — React is the only supported frontend framework
Third-party authentication: Facebook login, GitHub login, Auth0, and other external auth providers — Caffeine uses Internet Identity
Real-time communication: WebSockets, Socket.io, server-sent events, push notifications
Mapping and location: External map services, GPS, and geolocation platforms (Google Maps, Mapbox, etc.) are not available. The AI can use the browser's built-in geolocation API to read a user's current position, and can embed static map images in your app.
Crypto wallets: MetaMask, WalletConnect, and other wallet integrations
Social media APIs: Instagram, TikTok, and similar platform APIs. X/Twitter posting (tweets, retweets, quote-tweets, and status updates) is supported — see below. Reading from X (timeline, search, user lookup) is not currently supported.
SMS and messaging: Twilio, WhatsApp, and similar services
If you describe something that requires one of these, the AI will tell you it's not supported and suggest the closest available alternative.
Device capabilities
Caffeine apps can access certain hardware features of the user's device through the browser:
Camera capture — your app can capture photos or video directly from the device camera. This is useful for profile photo uploads, document scanning, inspection apps, or any feature that needs an image taken in the moment rather than uploaded from a gallery.
QR code scanning and generation — your app can use the device camera to scan QR codes and can also display QR codes on screen. Useful for ticketing systems, check-in flows, product lookups, or sharing links.
To add these to your app, describe what you want: "let users take a photo from their camera to set their profile picture" or "add a QR code scanner for checking in attendees."
X/Twitter posting
Caffeine apps can post to X (formerly Twitter) on behalf of your users — including tweets, retweets, quote-tweets, and status updates. The AI sets up the full OAuth 2.0 PKCE flow so each user can authorise their own X account, and creates an admin configuration page where a site administrator enters the X Client ID once for all users. Posting is handled securely through a dedicated extension that manages authentication and protects your credentials.
Reading from X — timelines, search results, and user profiles — is not yet covered by this integration.
To add X posting to your app, describe it in your prompt: "let users post a tweet from their dashboard" or "add a button that shares a result to X."
Third-party libraries and packages
Caffeine apps can use packages from npm (frontend JavaScript libraries) and mops (Motoko backend packages). You do not need to know specific package names — describe the capability you want and the AI will install and integrate the appropriate library. This extends what your app can do well beyond the core stack: rich text editors, charting, mapping, drag and drop, 3D graphics, audio, PDF generation, and much more on the frontend; advanced data structures, HTTP utilities, and Caffeine's own integration packages on the backend.
See Packages and Skills for a full overview with examples.
Fonts
Caffeine apps come with a set of self-hosted fonts bundled directly into your app — they load instantly and don't depend on any external service. The AI can also use Google Fonts as a fallback when the right font isn't in the bundled set, since your app's frontend runs in the browser and can fetch external resources.
The bundled fonts are:
Display and heading fonts
Fraunces, Playfair Display, Bricolage Grotesque, DM Serif Display, Instrument Serif (italic accent only)
Body and UI fonts
General Sans, Figtree, Plus Jakarta Sans, Satoshi, DM Sans
Monospace fonts
JetBrains Mono, Geist Mono
Special-purpose fonts
Parisienne (script/cursive — only when explicitly requested for handwritten or luxury styling)
The AI selects fonts as part of the visual design process. You can request a specific font by name, or describe the typographic feeling you want ("something elegant and editorial" or "clean and modern") and the AI will choose accordingly.
Project complexity
Caffeine uses a team of specialist AI agents that work in parallel, with each agent handling a specific part of the build. Every build starts with a fresh scan of your project, and each agent receives only the context it needs — not the entire project history. This means Caffeine can handle significantly larger and more complex projects than traditional single-agent AI builders.
That said, there are still practical limits. Very large projects with many interconnected features require more coordination between agents, and extremely complex changes may take longer or need to be broken into smaller steps. As models improve and Caffeine's agent architecture evolves, the threshold for what can be built reliably continues to increase.
If your project reaches a complexity where builds become unreliable, the recommended approach is to export your project to GitHub and continue development using external tools or a developer. GitHub import is coming soon, which means you will be able to export, make changes externally, and import the project back into Caffeine. A Caffeine CLI and SDK are also in development — these will let you interact with the Caffeine platform programmatically, giving you more control over complex projects.
For practical advice on keeping builds reliable as your project grows, see When Builds Fail.
Frequently asked questions
Can I request a font that isn't in the bundled list?
Yes — the AI can use Google Fonts as a fallback when a font you want isn't bundled. If a Google Fonts version exists, the AI can include it via an @import. If no suitable alternative exists, the AI will pick the closest match from the bundled options.
Can Caffeine build a mobile app?
Caffeine builds web apps that work on mobile browsers. Native iOS or Android apps (via React Native, Flutter, or similar) are not supported.
Can I add a database like PostgreSQL?
No. Data storage is handled by the Internet Computer's built-in persistence model. There is no external database layer. For most app use cases this is seamless — you describe what data you want to store and the AI handles the implementation.
Can I add OpenAI or chatbot features to my app?
Yes. Caffeine has a built-in OpenAI integration that lets you add chatbot, ChatGPT, embeddings, and other OpenAI-powered features to your app. When you describe what you want — "add a chatbot that answers questions about my product" or "use OpenAI to summarise user submissions" — the AI sets up the integration automatically. You will need to provide an OpenAI API key, which Caffeine handles securely as part of the setup. See Packages and Skills for an overview of available integrations.
Can I add npm packages or third-party libraries?
Yes. The AI can install packages from npm for the frontend and from mops for the Motoko backend. Describe what you want — "add a drag-and-drop kanban board" or "add a rich text editor" — and the AI will choose and install the right package. See Packages and Skills for more detail and examples.
Can my app access the user's location?
Yes, to a limited degree. The AI can use the browser's built-in geolocation API to read the user's current position. What isn't supported is integration with external map services like Google Maps or Mapbox — but if you need a map, the AI can embed a static map image from a public source.
Can my app use the device camera?
Yes. Caffeine apps can capture photos or video from the device camera. You can use this for profile photos, document scanning, or any feature that needs an image captured on the spot.
Can my app scan or display QR codes?
Yes. The AI can add QR code scanning (using the device camera) and QR code generation (displaying a scannable code on screen) to your app.
Can my app post to X (Twitter)?
Yes. Caffeine supports posting tweets, retweets, quote-tweets, and status updates to X on behalf of your users. Each user connects their own X account through an OAuth 2.0 flow, and an admin configuration page lets a site administrator set the X Client ID once. Reading from X — timelines, search, and user lookup — is not currently supported.
What if I need a technology that's not on the list?
Describe what you want to achieve rather than how you want to achieve it. The AI often finds a way to deliver the outcome using the supported stack. If something is genuinely impossible within the constraints, the AI will tell you directly.