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)
- 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: GPS, maps, geolocation services
Crypto wallets: MetaMask, WalletConnect, and other wallet integrations
Social media APIs: Twitter/X, Instagram, TikTok, and similar platform APIs
LLM integrations: OpenAI, Anthropic, and other AI provider APIs cannot be called from within a generated app
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.
Third-party JavaScript libraries
You cannot add packages to package.json. The frontend dependency list is fixed as part of the Caffeine stack and cannot be extended.
However, many JavaScript libraries can be loaded via CDN instead — services like jsDelivr or cdnjs host thousands of libraries that can be included in your app using a <script> tag in the HTML. Ask Caffeine to do this for you:
- "Add the Leaflet mapping library to the app using a jsDelivr CDN script tag"
- "Include Chart.js via CDN and use it to render a bar chart on the dashboard"
The AI will add the appropriate <script> tag and write the code to use the library. This works for libraries that expose a global variable (the traditional UMD/IIFE format) and many modern ES module-compatible libraries.
Note that CDN-loaded libraries are fetched from an external server at page load time. This is fine for most use cases but means the library requires an internet connection to load — it is not bundled into the app itself.
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
Like all AI-powered builders, Caffeine works best when projects are within a size the AI can reason about effectively. As your project grows — more backend functions, more pages, more interconnected logic — the AI has to consider more code with each change. At a certain point, the quality of generated code can start to decrease because the AI is working at the edges of what it can hold in context at once.
This is not a limitation specific to Caffeine — it is inherent to how large language models work. Every AI builder faces the same constraint, and the threshold improves as models evolve. Caffeine's capacity to handle large and complex projects increases over time as new models with larger context windows and better reasoning become available.
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 call the OpenAI API from my app?
Not currently. LLM API integrations are not supported in generated apps. For AI-powered features within your app, describe the functionality you want and the AI will implement it using the available capabilities.
Can I add packages to package.json?
No. The frontend dependency list is fixed and cannot be extended. You cannot install additional npm packages.
Can I use third-party JavaScript libraries that aren't in the stack?
Often yes, via CDN. Many libraries are available through services like jsDelivr or cdnjs and can be loaded using a <script> tag rather than an npm install. Ask the AI to add the library for you: "Include the Leaflet library via jsDelivr CDN." The AI will add the script tag and write the integration code.
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.