Connect GitHub
Keep the project source in GitHub. This is the connected provider available in the public workflow.
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
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.
Compatibility table
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.
| Framework | Supported? | Build output | Typical build command | Notes | Recommended? |
|---|---|---|---|---|---|
| Plain HTML | Fully supported | Repository files | No build required | HTML, CSS, JavaScript and assets publish as static files. | Yes |
| Bootstrap | Usually supported | Static files | None or project build | Fits when the finished site is static. | Yes |
| Tailwind CSS | Usually supported | Static files or dist | npm run build | Generated CSS must be in the publishable output. | Yes, when static |
| Alpine.js | Usually supported | Static files | None or project build | Fits when no server-side application is required. | Yes |
| Vite | Fully supported | dist | npm run build | Recognised by the current build registry. | Yes |
| React with Vite | Fully supported | dist | npm run build | A Vite static build is the relevant supported path. | Yes |
| Create React App | Fully supported | build | npm run build | The registry recognises the react-scripts pattern. | Yes, for existing static projects |
| React, other setups | Usually supported | Usually dist, build, out or public | npm run build | The project must build to a complete static site. | Usually |
| Astro | Fully supported | dist | npm run build | Supported when configured for static output. | Yes |
| Vue CLI | Fully supported | dist | npm run build | The Vue CLI static build pattern is recognised. | Yes |
| Vue + Vite | Fully supported | dist | npm run build | Vite detection covers this static build pattern. | Yes |
| Vue, other setups | Requires review | Varies | Usually npm run build | Confirm static output and actual publish folder. | Review first |
| Next.js static export | Fully supported | out | npm run build | Use static export; server-only features must not be required. | Yes, when exported |
| Next.js server application | Conditional | Managed Node HTTP runtime | npm start | It 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 |
| Express | Conditional | Managed Node HTTP runtime | npm start | A supported Express HTTP app can fit when it meets the managed Node 22 start, PORT and /health contract. | Review first |
| Vanilla Node HTTP server | Conditional | Managed Node HTTP runtime | npm start | A supported Node HTTP app can fit when it uses the supplied PORT and exposes /health. | Review first |
| Nuxt static generation | Requires review | Configured static output | Project command | Its output and command need checking first. | Review first |
| Nuxt SSR | Not currently supported | Server runtime | Not applicable | SSR requires a running application runtime. | No |
| Svelte | Requires review | Often dist or build | npm run build | A client-side static build can fit; check output and adapter. | Review first |
| SvelteKit static | Requires review | Often build | npm run build | It must use a static adapter and generate complete files. | Review first |
| SvelteKit SSR | Not currently supported | Server runtime | Not applicable | Server adapters are outside the current workflow. | No |
| Solid with Vite | Fully supported | dist | npm run build | The Vite static pattern is supported. | Yes, when Vite static |
| SolidStart | Not currently supported | Usually server runtime | Not applicable | Treat runtime-dependent SolidStart as dynamic. | No |
| Angular | Requires review | Often nested dist | npm run build | Output structure varies by project. | Review first |
| Eleventy | Requires review | Commonly _site | Project command | Default output is not an explicit current detection path. | Review first |
| Hugo | Requires review | Commonly public | hugo | Public build path is npm-based; use reviewed/prebuilt output. | Review first |
| Jekyll | Not currently supported | Commonly _site | jekyll build | Jekyll normally needs a Ruby toolchain. | No |
| MkDocs | Not currently supported | Commonly site | mkdocs build | MkDocs normally needs a Python toolchain. | No |
| Docusaurus | Requires review | Commonly build | npm run build | It can produce static output but needs dependency/output review. | Review first |
| Gatsby | Requires review | Commonly public | npm run build | Static output is possible; review dependencies and output. | Review first |
How publishing works
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.
Keep the project source in GitHub. This is the connected provider available in the public workflow.
Choose Static site for finished files or Node.js application for a supported HTTP application.
Static projects produce output; Node applications start with npm start and use the supplied PORT.
A Node application must answer GET /health; successful deployments receive an HTTPS preview URL.
Use deployment/runtime logs, correct the project in GitHub, and publish the next version through the same route.
PHP, databases, Docker and arbitrary workers need a different hosting model.
Before connecting GitHub
A short pre-flight check avoids treating a project-fit problem as a hosting problem after deployment has begun.
dist, build, out and public; check rather than assume.Why some frameworks work
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.
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 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.
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.
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.
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
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.
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.
Recognised frontend projects need a usable npm build script. Fix missing dependencies and failed build steps in GitHub before publishing again.
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.
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.
Test relative/base paths in the built site. If images, fonts or scripts are missing, inspect the project build and deployment result first.
Choose the correct product
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.
These need a PHP application runtime and often supporting services.
Use Host Luma Managed WordPress Hosting for WordPress and its PHP/database requirements.
Containers and arbitrary persistent workers are outside the managed Node web-application scope.
Server-side rendering or application frameworks are not automatically supported because they use Node; they must meet the supported runtime contract.
Applications requiring a database service need an appropriate application environment.
Preparing common projects
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.
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 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.
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.
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.
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.
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.
Static versus dynamic
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 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.
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.
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.
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.
Developer FAQ
Yes. The current supported frontend build path uses npm to install dependencies and run the project build script for recognised projects.
They are not currently presented as supported package-manager contracts. Use an npm-compatible project or contact support before relying on pnpm or yarn.
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.
Yes, when the application’s deploy-key access is configured and verified. Do not assume a private repository will publish without that access setup.
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.
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.
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.
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
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.
When to ask for help
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.