菜单
SolidJS Documentation documentation and resources. Use this skill when working with SolidJS Documentation or when the user mentions solidjs documentation.
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
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.
