Menu
SolidJS Documentation documentation and resources. Use this skill when working with SolidJS Documentation or when the user mentions solidjs documentation.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Based on SOC occupation classification
Ansible is a radically simple IT automation platform that makes your applications and systems easier to deploy and maintain. This llms.txt indexes the official Ansible Community Documentation (latest stable). Source: https://docs.ansible.com/projects/ansible/latest/
A proposal that those interested in providing LLM-friendly content add a /llms.txt file to their site. This is a markdown file that provides brief background information and guidance, along with links to markdown files providing more detailed information.
An ultra-portable web-browser engine for games and desktop apps.
Documentation - Discord documentation and resources. Use this skill when working with Documentation - Discord or when the user mentions documentation - discord.
The official documentation for building on the Slack platform: apps, agents, workflows, and integrations. Covers the Slack CLI, Bolt frameworks (JavaScript, Python, Java), SDKs, the Web and Events APIs, Block Kit, authentication, and Slack Marketplace distribution.
Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
| name | solidjs |
| description | SolidJS Documentation documentation and resources. Use this skill when working with SolidJS Documentation or when the user mentions solidjs documentation. |
| metadata | {"source":"llms.txt","source_url":"https://docs.solidjs.com/llms.txt","generated":"2026-04-29T02:48:54.551Z"} |
Basics: Learn Solid component fundamentals: creating reusable UI blocks, component trees, lifecycles, and proper import/export patterns.
Class and style: Style Solid components with CSS classes and inline styles. Learn dynamic styling, classList usage, and theme implementation.
Props: Pass and manage component props in Solid while maintaining reactivity. Learn mergeProps, splitProps, and best practices.
Event handlers: Handle user interactions in Solid with event delegation and native events for optimal performance and resource management.
Intro to reactivity: Master Solid's reactive system fundamentals: signals, subscribers, and automatic UI updates for responsive applications.
Conditional rendering: Conditionally render UI elements in Solid using Show, Switch, and Match components for clean, readable conditional logic.
List rendering: Efficiently render dynamic lists in Solid using For and Index components. Optimize performance for different data scenarios.
Dynamic: Render components dynamically at runtime with Solid's Dynamic component. Build flexible UIs with runtime component selection.
Error boundary: Catch and handle rendering errors gracefully with ErrorBoundary. Prevent app crashes and provide user-friendly error recovery.
Portal: Learn how Portal renders elements outside the normal DOM flow to solve z-index and overflow issues for modals and popups.
Understanding JSX: Write HTML-like syntax in JavaScript with JSX to create reactive components with dynamic expressions and event handlers.
Derived signals: Create reactive derived values that automatically update when their dependencies change using Solid's derived signals.
Memos: Optimize expensive computations with memos that cache results and only recalculate when dependencies actually change.
Signals: Create reactive state with signals - the foundation of Solid's reactivity system for automatic UI updates and tracking.
Effects: Manage side effects like DOM updates, API calls, and subscriptions that respond automatically to reactive state changes.
Context: Share data across component trees with Solid's Context API. Avoid prop drilling and manage global application state effectively.
Stores: Manage complex nested state efficiently with stores that provide fine-grained reactivity for objects and arrays in Solid.
Refs: Access and manipulate DOM elements directly using refs, forward refs between components, and create custom directives.
CSS modules: Use CSS Modules in Solid for locally scoped styles, preventing global conflicts and ensuring component style encapsulation.
LESS: Integrate LESS preprocessor in Solid apps for variables, mixins, and programmatic CSS features to write cleaner stylesheets.
Macaron: Style Solid components with Macaron's compile-time CSS-in-JS, offering type-safe styled components and variant-based styling.
SASS: Configure SASS/SCSS in Solid projects for advanced CSS preprocessing with variables, nesting, mixins, and modular stylesheets.
Tailwind CSS v3: Set up Tailwind CSS v3 in Solid apps for utility-first styling, rapid development, and consistent responsive design patterns.
Tailwind CSS: Set up Tailwind CSS v4 in your Solid app for utility-first styling. Configure PostCSS, import styles, and build responsive UIs efficiently.
UnoCSS: Integrate UnoCSS with Solid for on-demand utility CSS. Configure Vite plugin, import styles, and create efficient atomic CSS designs quickly.
Styling your components: Explore Solid's flexible styling options: CSS preprocessors, CSS Modules, CSS-in-JS, and utility frameworks for component styling needs.
AWS via Flightcontrol: Deploy Solid apps to AWS with Flightcontrol's automated platform featuring GitHub integration and continuous deployment.
AWS via SST: Deploy SolidStart apps to AWS Lambda or containers using SST framework with streamlined configuration and deployment.
Cloudflare: Deploy Solid apps to Cloudflare Pages for fast, global edge hosting with built-in CDN and simple Git integration setup.
Firebase: Host your Solid application on Firebase with Google's infrastructure for reliable static site hosting and easy deployment.
Netlify: Deploy Solid apps to Netlify with automatic builds from Git, instant rollbacks, and powerful deployment features included.
Railway: Deploy Solid projects to Railway platform with GitHub integration, custom domains, and straightforward deployment process.
Stormkit: Deploy Solid apps as static sites or SPAs on Stormkit with serverless functions support and Git provider integration.
Vercel: Deploy SolidStart apps to Vercel with automatic builds, serverless functions, and GitHub integration for seamless production hosting.
Zerops: Deploy SolidStart apps to Zerops cloud platform with support for both static sites and SSR Node.js applications in production.
State management: Learn Solid's state management with signals, derived values, memos, and effects for reactive data flow and component updates.
Routing & navigation: Implement client-side routing in Solid apps with dynamic routes, nested layouts, route parameters, and lazy-loaded components.
Complex state management: Master complex state management in Solid using stores and context to build scalable, maintainable applications efficiently.
Fetching data: Master data fetching in Solid with createResource for async operations, loading states, error handling, and Suspense boundaries.
Testing: Test Solid apps with Vitest and Testing Library. Write component tests, simulate user interactions, and ensure code quality effectively.
Deploy your app: Deploy your Solid application to popular hosting platforms including Cloudflare, Vercel, Netlify, AWS, and more with guides.
Environment variables: Configure public and private environment variables in Solid apps using Vite's built-in support for secure configuration.
TypeScript: Learn to configure TypeScript with SolidJS for enhanced type safety, better IDE support, and reliable component development.
createEffect: Learn how to use createEffect to run side effects when reactive dependencies change. Perfect for DOM manipulation and external library integration.
createMemo: Use createMemo to efficiently compute and cache derived values. Prevent expensive recalculations and optimize your Solid.js application's performance.
createResource: Fetch async data with createResource. Handles loading states, errors, and integrates with Suspense for seamless data fetching in Solid.js applications.
createSignal: Create reactive state with createSignal, Solid's fundamental primitive. Track values that change over time and automatically update your UI when they do.
children: Resolve a component's children prop into a stable accessor.
createContext: Create a context object with a Provider component and a default value.
createUniqueId: Generate a unique string for the current render or hydration context.
lazy: Create a component that loads its module lazily from a dynamic import.
useContext: Read the current value of a context object created by createContext.
createDynamic: Render a component or intrinsic element selected at runtime from an accessor.
: Render a component or intrinsic element selected at runtime.
: Catch errors thrown while rendering or updating a subtree and render fallback content.
: Render a list by item identity with a child function that receives the item and an index accessor.
: Render a list by index with a child function that receives an item accessor and a numeric index.
: Render children during server rendering and skip hydration for that subtree on the client.
: Render children into a DOM node outside the parent DOM hierarchy.
: Render children when a condition is truthy, with optional fallback content and keyed behavior.
: Coordinate how multiple suspense boundaries reveal their content.
: Render fallback content while suspense-tracked async dependencies under the boundary are pending.
/ : Render the first matching branch from a set of mutually exclusive conditions.
attr:*: Force a JSX key to be written as an attribute instead of a property.
bool:*: Control whether an attribute is present by writing through bool:*.
classList: Toggle element classes from an object of class names and boolean values.
innerHTML: Set an element's innerHTML property from JSX.
on:*: Attach an event listener directly to an element with addEventListener.
on*: Attach an event handler with Solid's delegated event system when the event is supported.
@once: Mark a JSX expression as static at compile time.
prop:*: Force a JSX key to be written as a DOM property instead of an attribute.
ref: Capture a rendered element or forwarded component ref.
style: Set inline styles with a CSS string or an object of property names and values.
textContent: Set an element's textContent property from JSX with plain text content.
use:*: Attach a directive function to a native element with use:*.
onCleanup: Register a cleanup function on the current reactive scope. The cleanup runs when the scope is disposed or refreshed.
onMount: Register a function that runs once after the initial render of the current component or root.
batch: Group reactive updates so downstream computations run after the batch completes.
catchError: Establish an error boundary for work performed inside the provided function.
createRoot: Create non-tracked owner scopes in SolidJS for manual memory management. Essential for nested tracking scopes and preventing auto-disposal.
from: Convert an external producer or subscribable into a Solid accessor.
getOwner: Return the owner for the currently executing reactive scope.
indexArray: Reactively map an array by index and return an accessor for the mapped result.
mapArray: Reactively map an array by item identity and return an accessor for the mapped result.
mergeProps: Merge multiple prop sources into a single object while preserving reactive property access.
observable: Convert a Solid accessor into an Observable-compatible object.
on: Control effect dependencies explicitly with SolidJS's on utility. Define when effects run and manage tracking behavior for precise reactivity.
runWithOwner: Execute a function under the provided owner.
splitProps: Split a reactive props object into multiple reactive subsets and a remainder object.
startTransition: Start a transition and return a promise that resolves when the transition completes.
untrack: Execute a function without collecting dependencies from the current reactive scope.
useTransition: Return a pending-state accessor and a function that starts a transition.
DEV: Read the development-only DEV export from solid-js.
hydrate: Hydrate server-rendered HTML and attach Solid's client-side behavior to an existing DOM subtree.
hydrationScript: Generate the SSR hydration bootstrap script with HydrationScript or generateHydrationScript.
isDev: Read the boolean that indicates whether the imported solid-js/web bundle is the development browser bundle.
isServer: Read whether the current solid-js/web bundle is the server bundle.
renderToStream: Stream server-rendered HTML and continue writing async content as it resolves.
renderToStringAsync: Render HTML to a string after async suspense boundaries settle.
renderToString: Render HTML to a string synchronously on the server.
render: Mount a Solid root into a DOM node in the browser.
createComputed: Create an immediate reactive computation that runs synchronously when created and whenever its dependencies change.
createDeferred: Create a deferred accessor whose updates are scheduled for later execution or when the timeout is reached.
createReaction: Create a reaction that runs once when the tracked expression is invalidated.
createRenderEffect: Create a reactive computation that runs immediately during the render phase.
createSelector: Create a keyed boolean accessor that reports whether a key matches the current source value.
getRequestEvent: Read the current request event from solid-js/web.
createMutable: Create a mutable store proxy.
createStore: Create a reactive store and a setter function for structured state.
modifyMutable: Apply a modifier to a mutable store inside a batch.
produce: Create a store modifier that applies changes by mutating the current state through a helper proxy.
reconcile: Create a store modifier that reconciles existing state with a new value.
unwrap: Remove store proxy wrapping from a store or store subtree.
Reference these resources when working with SolidJS Documentation.
