Website and Node compatibility reference

Supported frameworks for AI website hosting.

Check whether a project built with Claude Code, Codex, Cursor or another tool can publish through Host Luma. This guide covers the static GitHub workflow and the bounded requirements for supported managed Node web applications.

Quick answer

Will my project work on Host Luma?

A static project is a good candidate when it produces HTML, CSS, JavaScript, images, fonts and browser assets. A supported Node web application is a good candidate when it deploys from GitHub, uses npm start, listens on the supplied PORT and exposes GET /health. The framework name alone is not the answer.

Available today: GitHub-connected publishing for supported static projects and supported managed Node 22 web applications, permanent preview URLs with HTTPS, custom domains, CDN delivery, deployment/runtime logs and version redeployment from a recorded successful Git commit. That redeployment uses the normal publishing path, not a snapshot, database or environment restore. Not provided: PHP, customer databases, Docker and arbitrary workers.

Compatibility table

Framework support depends on how the project runs, not its logo in package.json.

Static support means the project produces finished files. Managed Node support is conditional: the GitHub-deployed HTTP application must use npm start, the supplied PORT and GET /health. A framework name alone never promises a runtime.

FrameworkSupported?Build outputTypical build commandNotesRecommended?
Plain HTMLFully supportedRepository filesNo build requiredHTML, CSS, JavaScript and assets publish as static files.Yes
BootstrapUsually supportedStatic filesNone or project buildFits when the finished site is static.Yes
Tailwind CSSUsually supportedStatic files or distnpm run buildGenerated CSS must be in the publishable output.Yes, when static
Alpine.jsUsually supportedStatic filesNone or project buildFits when no server-side application is required.Yes
ViteFully supporteddistnpm run buildRecognised by the current build registry.Yes
React with ViteFully supporteddistnpm run buildA Vite static build is the relevant supported path.Yes
Create React AppFully supportedbuildnpm run buildThe registry recognises the react-scripts pattern.Yes, for existing static projects
React, other setupsUsually supportedUsually dist, build, out or publicnpm run buildThe project must build to a complete static site.Usually
AstroFully supporteddistnpm run buildSupported when configured for static output.Yes
Vue CLIFully supporteddistnpm run buildThe Vue CLI static build pattern is recognised.Yes
Vue + ViteFully supporteddistnpm run buildVite detection covers this static build pattern.Yes
Vue, other setupsRequires reviewVariesUsually npm run buildConfirm static output and actual publish folder.Review first
Next.js static exportFully supportedoutnpm run buildUse static export; server-only features must not be required.Yes, when exported
Next.js server applicationConditionalManaged Node HTTP runtimenpm startIt is not supported merely because it uses Next.js. Assess it only when it meets the managed Node 22 start, PORT and /health contract.Review first
ExpressConditionalManaged Node HTTP runtimenpm startA supported Express HTTP app can fit when it meets the managed Node 22 start, PORT and /health contract.Review first
Vanilla Node HTTP serverConditionalManaged Node HTTP runtimenpm startA supported Node HTTP app can fit when it uses the supplied PORT and exposes /health.Review first
Nuxt static generationRequires reviewConfigured static outputProject commandIts output and command need checking first.Review first
Nuxt SSRNot currently supportedServer runtimeNot applicableSSR requires a running application runtime.No
SvelteRequires reviewOften dist or buildnpm run buildA client-side static build can fit; check output and adapter.Review first
SvelteKit staticRequires reviewOften buildnpm run buildIt must use a static adapter and generate complete files.Review first
SvelteKit SSRNot currently supportedServer runtimeNot applicableServer adapters are outside the current workflow.No
Solid with ViteFully supporteddistnpm run buildThe Vite static pattern is supported.Yes, when Vite static
SolidStartNot currently supportedUsually server runtimeNot applicableTreat runtime-dependent SolidStart as dynamic.No
AngularRequires reviewOften nested distnpm run buildOutput structure varies by project.Review first
EleventyRequires reviewCommonly _siteProject commandDefault output is not an explicit current detection path.Review first
HugoRequires reviewCommonly publichugoPublic build path is npm-based; use reviewed/prebuilt output.Review first
JekyllNot currently supportedCommonly _sitejekyll buildJekyll normally needs a Ruby toolchain.No
MkDocsNot currently supportedCommonly sitemkdocs buildMkDocs normally needs a Python toolchain.No
DocusaurusRequires reviewCommonly buildnpm run buildIt can produce static output but needs dependency/output review.Review first
GatsbyRequires reviewCommonly publicnpm run buildStatic output is possible; review dependencies and output.Review first
Warning: Next.js, Nuxt, SvelteKit and SolidStart are not support answers by themselves. A supported Node HTTP app may fit only when it meets the managed Node 22 contract; database, Docker, worker and unsupported framework requirements remain outside AI Hosting.

How publishing works

How Host Luma deploys your project.

GitHub is the connected project route available today. Host Luma either validates and publishes static output, or runs a configured supported Node 22 HTTP application through the managed lifecycle.

01

Connect GitHub

Keep the project source in GitHub. This is the connected provider available in the public workflow.

02

Choose deployment type

Choose Static site for finished files or Node.js application for a supported HTTP application.

03

Build or start

Static projects produce output; Node applications start with npm start and use the supplied PORT.

04

Health check and preview

A Node application must answer GET /health; successful deployments receive an HTTPS preview URL.

05

Review and iterate

Use deployment/runtime logs, correct the project in GitHub, and publish the next version through the same route.

06

Stay within scope

PHP, databases, Docker and arbitrary workers need a different hosting model.

Private repositories: they can be configured through a per-application deploy-key flow after required access is set up and verified. Organisation-owned repository access needs review and authorisation; it is not a blanket self-service promise.

Before connecting GitHub

Prepare the project before you publish.

A short pre-flight check avoids treating a project-fit problem as a hosting problem after deployment has begun.

  • Use a GitHub repositoryKnow which branch contains the version you intend to publish.
  • Confirm static outputCheck that the completed site works without an always-on server process.
  • Run the production buildFor a framework project, use its normal build command before connecting it.
  • Know the output folderCommon names include dist, build, out and public; check rather than assume.
  • Keep secrets out of sourceDo not commit private keys, passwords or `.env` values that should remain private.
  • Test the finished siteCheck key pages, assets, external forms and navigation in the production build.
Tip: test the production build, not only the development server. A development server can hide problems that appear after static output is created. The final static files are the artefact this hosting model needs.

Why some frameworks work

A framework is a fit when its production contract is clear, not when it has a fashionable name.

Static HTML and browser assets

Plain HTML, Bootstrap and Alpine.js can be excellent fits when the repository already contains a finished static site. There is no application server to keep running.

Vite, React, Vue and Astro

These commonly use an npm build to create a dist directory. The current build registry recognises the Vite, Astro and Vue CLI patterns and uses their static output.

Next.js static export

Next.js can be a strong fit when configured to export static files. A project that needs server-side rendering, request-time data or server actions has a different runtime requirement.

Generic npm builds

Some projects have a build script but are not named framework patterns. Common static output directories can be assessed, but generic does not mean automatically compatible.

External services

A static site can link to a booking tool, form provider or browser-side API. That does not mean Host Luma is hosting the service, API or database behind it.

Managed Node web applications

Supported Node 22 HTTP applications need the managed GitHub deployment route, npm start, the supplied PORT and GET /health. PHP, Docker, databases and arbitrary workers remain outside this scope.

Troubleshooting starts with fit

Common build mistakes.

Wrong output folder

A build can succeed while its files sit in a folder the publishing path does not expect. Do not assume `dist`, `build`, `out`, `public`, `_site` and `site` mean the same thing.

Forgot static export

Next.js, Nuxt and SvelteKit can look static while still requiring server-side rendering. Configure and test a real static export before choosing static hosting.

Missing build command

Recognised frontend projects need a usable npm build script. Fix missing dependencies and failed build steps in GitHub before publishing again.

Environment variables

Static output can safely contain only values intended to be public in the browser. A secret needed at request time means the project needs a server-side component.

Broken dependencies

Test the production build locally. A failed dependency install or unsupported native dependency is a project issue, not a reason to edit server files manually.

Broken asset paths

Test relative/base paths in the built site. If images, fonts or scripts are missing, inspect the project build and deployment result first.

When a build fails: begin with the framework fit, local production build, expected output directory and deployment result. Make the correction in GitHub, then use the same connected route for the next publish. This keeps source and publishing history connected.

Choose the correct product

When AI Hosting is not the right runtime.

Host Luma AI Hosting is not a general application platform. Its dynamic path is limited to supported Node 22 HTTP applications with the documented start, PORT and health contract. The following needs require a different hosting model today.

PHP and Laravel applications

These need a PHP application runtime and often supporting services.

WordPress

Use Host Luma Managed WordPress Hosting for WordPress and its PHP/database requirements.

Docker, workers and queues

Containers and arbitrary persistent workers are outside the managed Node web-application scope.

Unqualified server-side frameworks

Server-side rendering or application frameworks are not automatically supported because they use Node; they must meet the supported runtime contract.

Database-backed applications

Applications requiring a database service need an appropriate application environment.

Do not force an application into the wrong runtime. A simple interface can still depend on a database, container or worker. For WordPress, choose the Managed WordPress product; for anything outside the documented Node web-application scope, use hosting that explicitly supports the required services.

Preparing common projects

How to prepare a static site for publishing.

The safe route is to make the production output explicit before you connect GitHub. A project that starts easily in development can still need a different hosting model after you inspect its real build.

Vite projects

Run the project’s normal production build and inspect the generated dist directory. Check that your main pages, images and browser-side navigation work from the built result. Vite is a recognised current static pattern, but your own base-path and asset settings are still part of the project.

Astro websites

Astro is a good fit when it generates static output. Build the project, inspect dist, and check that any integrations do not change the site into a request-time server application. A fast static site can still include external forms or analytics; those services remain separate from the static host.

Next.js exports

Use a real static-export configuration, not a development server as a stand-in for production. Next.js documents static export with output: 'export'; a successful build creates an out directory containing static assets. Server actions, dynamic request behaviour and other server-only features do not fit this route.

Vue and React

For Vite-based projects, use the normal build command and inspect dist. For an older Create React App project, inspect build. If a React or Vue project uses a custom server, protected API or process at request time, assess whether it meets the separate managed Node contract.

Documentation generators

Docusaurus, Eleventy, Hugo, Jekyll and MkDocs are all capable of producing static pages, but their normal tools and output folders differ. A framework that produces files is not automatically a supported build contract. Review whether your project needs npm, Ruby, Python, Go or a non-standard output location before treating it as ready.

AI-generated projects

Claude Code, Cursor, Lovable, Bolt, v0, ChatGPT and Gemini can help create a website. They are not by themselves a hosting compatibility signal or a Host Luma integration. Open the repository, identify the framework, run the production build and check whether the published result can be static or meet the supported managed Node contract.

A useful decision test: if the project can build today, produce a non-empty output directory and work without an application process listening for web requests, it is a sensible static-hosting candidate. If it needs an HTTP process, assess the documented managed Node requirements; databases, Docker and arbitrary workers need a different hosting model.

Static versus dynamic

Why the output matters more than the framework name.

A static website is a set of finished files. A dynamic application runs code after a visitor makes a request. Both can use the same front-end framework, which is why compatibility needs more than a framework label.

A static project

A landing page built with React can be static when the build creates browser files and all visitor interaction happens in the browser or through an external service. Host Luma can assess that static output.

A dynamic project

The same React interface becomes a different hosting requirement if it depends on a custom API, session server, database query or request-time authentication controlled by the application.

Framework configuration matters

Next.js, Nuxt and SvelteKit can all generate static pages in one configuration and require an application runtime in another. Check the real production output, not the development command.

Preview before assumption

The current workflow gives a successful supported project a permanent HTTPS preview URL. It is useful for review and sharing; it does not turn a server-dependent application into a static site.

Before you choose a host, ask: does a visitor’s request need my own server code to run? If the answer is yes, static publishing is not the complete hosting solution. If the answer is no and the build produces finished files, the project is a strong candidate for this workflow.

Developer FAQ

Answers before you connect a project.

Can I use npm?

Yes. The current supported frontend build path uses npm to install dependencies and run the project build script for recognised projects.

Can I use pnpm or yarn?

They are not currently presented as supported package-manager contracts. Use an npm-compatible project or contact support before relying on pnpm or yarn.

Can I use monorepos?

Monorepos are not a public self-service support promise. The current build starts from the connected repository root, so contact support with the project layout and intended static application before depending on a monorepo workflow.

Can I use private repositories?

Yes, when the application’s deploy-key access is configured and verified. Do not assume a private repository will publish without that access setup.

Can I reconnect GitHub?

Do not assume a self-service reconnect control. Contact support if a repository connection needs to change so access and deployment configuration can be reviewed safely.

Can I redeploy?

Correct or update the project in GitHub and publish the next change. For a recorded successful Git commit, the Portal can also queue a previous-version redeployment through the normal publishing path; it is not a snapshot, database or environment restore.

Can I delete deployments?

Host Luma does not currently present a customer-facing deployment-deletion control as part of the public workflow. Contact support if you need help with a published project.

Do I get a custom domain or CDN?

Yes. Every AI Hosting project receives a permanent HTTPS preview URL, and you can attach one custom domain per project from the portal with global CDN delivery included.

Accuracy and review

A compatibility reference tied to the live product.

This page describes the public AI Hosting workflow for supported static website projects. It does not claim that AI tools are Host Luma integrations, and it does not present roadmap work as available. Framework statuses follow the current build registry and public product boundaries.

Host Luma support can help with the hosting-side publishing workflow, preview URLs, HTTPS, account access and deployment state. Your code, project configuration, external services and content remain your responsibility. Read the content standards for how public claims are reviewed.

Page owner: Host Luma editorial team. Technical review: Host Luma hosting team. Last updated: 1 August 2026.

Revision history

Version 1, 1 August 2026: initial public framework compatibility reference with build-pattern boundaries, developer FAQ and framework-by-framework support table.

When to ask for help

Contact support before a wrong-fit deployment.

Ask for a review when the project uses a non-npm toolchain, has a non-standard output folder, depends on a monorepo, needs private-repository access or might use server-side rendering. Sharing the framework, build command, output folder and intended published application gives support the information needed to discuss the hosting-side fit clearly.