Cursor Rules Guide

This document details best practices for tinygrad library development. It covers general principles like readability and TDD, code organization, design patterns, performance optimization, security, testing, and tooling. Adhering to these guidelines ensures code readability, maintainability, and optimal performance in tinygrad projects.

This document details best practices for using the `notion-api` library. It covers code organization, design patterns, performance optimization, security, testing, and more. Follow these guidelines to create maintainable, performant, secure, and testable Notion integrations, and avoid common pitfalls and errors.

This document offers guidance on LlamaIndex app development. It covers code organization, common patterns, performance, security, testing, and more. It details directory structures, naming conventions, optimization techniques, and best practices for input validation, authentication, and deployment. Also warns about common pitfalls and suggests tools and environments for development.

This document provides best practices for LlamaIndex - JS projects. It covers code organization (directory structure, naming conventions), common patterns, anti - patterns, performance optimization, security, testing, and tooling. Following these guidelines helps build robust, efficient, and secure AI applications.

This document details best practices for the Hugging Face Transformers library. It covers code organization, common patterns, performance, security, testing, and more. It emphasizes single - model file policy, offers optimization techniques, and warns against common pitfalls like prompt injection and incorrect tokenization.

This document offers comprehensive guidelines for using Mockito in Java projects. It covers code organization, common patterns, performance, security, testing, and pitfalls. It details how to structure code, use Mockito annotations, optimize performance, prevent security vulnerabilities, and test different scenarios effectively.

These rules focus on Nuxt.js development. They cover enabling ESLint, adopting modules, following conventions, and optimizing performance. Also, they include security, testing, and avoiding common mistakes. With proper code organization, component design, and state management, you can build robust, maintainable Nuxt.js apps.

These rules cover various aspects of LangChain JS development. It includes monitoring with LangSmith, building stateful agents with LangGraph, maintaining code quality through testing and linting, and using LCEL for chain composition. Also, it provides guidance on code organization, design patterns, performance optimization, security, testing, and tooling.

This document provides comprehensive best - practices for Java development. It covers code organization, common patterns, performance, security, testing, pitfalls, and tooling. Following these guidelines helps write clean, efficient, and secure Java code, and can be adjusted according to project needs and team preferences.

These rules aim to ensure high - quality LLVM code. It covers coding standards, language usage, source formatting, and performance. Adhere to LLVM's style, use modern C++ and Python, manage memory efficiently, and follow best practices in testing, security, and tooling. Avoid common pitfalls and contribute to a consistent codebase.

This guide details best practices for jQuery development. It covers code organization, common patterns, performance optimization, security, testing, and tooling. It provides tips on directory structure, design patterns, selector optimization, and more, aiming to ensure code quality, performance, and maintainability.

This document details best practices for Netlify app development. It covers code organization, performance, security, testing, and deployment. For example, it suggests a specific directory structure, using design patterns like JAMstack, optimizing performance via code splitting, and implementing security measures such as input validation and HTTPS for API communication.

This guide details isort best - practices in Python projects. It covers code organization (directory structure, file naming), common patterns, performance, security, testing, pitfalls, and tooling. It offers tips like using modular structure for large projects, sorting imports automatically, and integrating with other tools in CI/CD.

This guide details best practices for Keras development. It covers code organization, common patterns, performance, security, testing, and tooling. For example, it suggests a clear directory structure, using design patterns like the Functional API, optimizing performance via GPU acceleration, and implementing various security and testing measures.

This document details best practices for using Mypy in Python projects. It covers gradual typing, consistent configuration, advanced feature usage, code organization, common patterns, performance, security, testing, and more. Following these guidelines can enhance code maintainability, robustness, and readability.

This document outlines best practices for LangChain application development, covering code organization, common patterns, performance, security, testing, common pitfalls, and tooling. It aims to ensure code quality, maintainability, performance, security, and overall project success.

This document outlines best practices for using Matplotlib, a Python library for visualizations. It covers code organization, design patterns, performance, security, testing, common pitfalls, and tooling.

This document outlines best practices for Next.js development, covering code organization, common patterns, performance, security, testing, pitfalls, and tooling. It helps build robust, scalable, and maintainable applications.

This set of rules is for Java backend development. It includes project configuration, AI developer profile, technical stack details, and comprehensive development guidelines based on 'Effective Java'. Also, it covers best - practices in concurrency, functional programming, and data - oriented programming.

Rules for programming with the latest version of HTML, Tailwind CSS and vanilla JavaScript. It includes requirements like following user's needs precisely, providing accurate code, focusing on readability, etc.

These rules cover various aspects of a Next.js, Supabase, Shadcn PWA project. They include code quality and style guidelines such as writing concise, strongly - typed code, using functional programming, and following naming conventions. Rules for build notes involve location, naming, content structure, update times, style, and handling of completed or deprecated notes. Context file rules specify the purpose, update conditions, and change management of master and additional context files. The project also has requirements for stack and framework usage, monorepo structure, and tooling.

This rule set provides guidelines and best practices for building Netlify projects and sites. It covers various aspects such as general rules, different types of compute systems (serverless, edge, background, and scheduled functions), Netlify Blobs for storage, Netlify Image CDN for image optimization, environment variables management, file - based uploads, and procedures for creating, initializing, and linking sites.

Comprehensive rules for AI-assisted development in a Next.js project with TypeScript, shadcn/ui, Tailwind CSS, and LLM integration.

Pyllments is a Python library designed for building graphical and API-based LLM applications by chaining together Elements in a potentially cyclic graph. It emphasizes modularity, extensibility, and developer-friendly interfaces.

Comprehensive guide to developing Chrome Extensions using JavaScript, HTML, CSS, and Chrome APIs. Learn best practices, performance optimization, security, and more.

Comprehensive guidelines for writing clean, maintainable, and high-performance JavaScript/TypeScript code. Follow these best practices to ensure your code is simple, readable, and reusable.

A streamlined pipeline for downloading, quantizing, and uploading models to Hugging Face repositories, optimized for Linux servers with NVIDIA CUDA and AMD ROCm GPU support.

Comprehensive and user-friendly Kubernetes documentation created using MkDocs, focusing on cloud-native technologies, containerization, and orchestration best practices.

Best practices and guidelines for building scalable, high-performance web applications using Astro and Tailwind CSS.

A comprehensive full-stack application built with Node.js, MongoDB, JWT for authentication, Express.js for the backend, and React.js for the frontend. This project includes a robust admin panel, secure authentication, and efficient data management.

A robust backend system built with Node.js and MongoDB for managing user pools, entries, picks, and scoring in a competitive gaming environment.

Comprehensive guide and best practices for building modern web applications using the TALL stack Laravel, Livewire, Alpine.js, and Tailwind CSS. This guide emphasizes Laravel and PHP best practices, performance optimization, and security measures.

Comprehensive guide and best practices for developing Laravel packages using PHP 8.3, focusing on code quality, developer experience, and seamless integration.

A comprehensive guide for building scalable, serverless applications using Knative, Istio, Typesense, and GPU acceleration. This project focuses on creating a robust, efficient, and secure AI-powered search application with a responsive HTMX-based frontend.

A comprehensive guide for Java developers using Spring Boot and JPA, focusing on best practices, SOLID principles, and OWASP security standards.

Best practices and guidelines for integrating HTMX with Django to build dynamic web applications efficiently.

A comprehensive guide to integrating HTMX with Flask, including best practices, folder structure, and additional instructions for building modern web applications.

A comprehensive guide to setting up HTMX with best practices, folder structure, and additional instructions for optimal performance and maintainability.

Best practices and guidelines for integrating HTMX with Go and Fiber, including project structure, coding standards, and performance optimization.

A comprehensive guide to setting up a Go project with HTMX, including best practices, folder structure, and additional instructions for efficient development.

Comprehensive guide for building secure, scalable, and maintainable REST APIs using Go's net/http package and the new ServeMux introduced in Go 1.22. Follow best practices for RESTful API design, error handling, input validation, and concurrency.

A modern portfolio project built with Next.js, featuring Material UI, Tailwind CSS, and Shadcn/UI for a responsive and visually appealing design. This project supports TypeScript, App Router, and a structured `src/` directory for better organization.

Comprehensive guide and rules for implementing best practices in Next.js App Router projects, including folder structure, coding standards, and performance optimization.

Comprehensive guide for integrating AI SDK RSC with Vercel middleware and KV database in a Next.js project using TypeScript, Tailwind CSS, and Shadcn UI.

BA Copilot is an AI-powered assistant designed to help business analysts create, modify, and iterate on BPMN diagrams with contextual suggestions, leveraging uploaded documents and user queries. Built with Next.js, Vercel, and Supabase, it offers a seamless workflow for business process modeling and documentation.

Astral is the Block Explorer for the Autonomys Network, built with Next.js, TypeScript, and Tailwind CSS. It provides a responsive and accessible interface for exploring blockchain data, integrating advanced libraries for state management, UI components, and data fetching.

Comprehensive guide for building a full-stack application using Next.js with TypeScript, integrating modern UI libraries, and optimizing for performance and scalability.

Astral is a Next.js and TypeScript-based block explorer for the Autonomys network, integrating state management, UI components, and data fetching libraries.

A comprehensive guide and rules for developing Next.js applications using Tailwind CSS for styling and TypeScript for type safety. This setup ensures a modern, efficient, and scalable web development environment.

A comprehensive guide and specifications for building a Todo application using Next.js and Supabase. This project leverages Supabase for backend services, Next.js for server-side rendering, and Tailwind CSS for styling.

Comprehensive guide for SEO optimization in Next.js projects, including best practices, coding standards, and performance tips.

Comprehensive guide for developing with Next.js, React, and TypeScript, focusing on best practices, performance optimization, and modern web development techniques.

A comprehensive guide and rules for developing modern web applications using Next.js, React, Tailwind CSS, and Shadcn UI. This setup emphasizes TypeScript, functional programming, and performance optimization.

Comprehensive guide and best practices for building modern web applications using Next.js 15, React 19, Vercel AI SDK, and Tailwind CSS. Includes TypeScript, Shadcn UI, Radix UI, and performance optimization strategies.

This rule offers best - practices for Databricks application development. It covers code organization, common patterns, performance optimization, security, testing, and tooling. For example, it details directory structure, design patterns, and security measures. Following these can help build maintainable, efficient, and secure applications.

This document provides comprehensive best - practices for Angular app development. It covers code organization, common patterns, performance, security, testing, and tooling. It details directory structure, design patterns, how to avoid anti - patterns, and offers strategies for optimization, security, and testing. Adhering to these can lead to robust, maintainable apps.

This guide details best practices for Apollo GraphQL API development. It covers schema design, security, performance optimization, code organization, testing, and more. It also provides tips on avoiding common pitfalls, using tools, and following additional practices like versioning and documentation.

This document offers guidelines for AnyIO library development. It covers code organization, common patterns, performance, security, testing, common pitfalls, and tooling. For example, it suggests using task groups for concurrency, asynchronous I/O for performance, and proper input validation for security.

This guide offers guidelines for high - quality pandas code. It covers code organization, common patterns, performance, security, testing, pitfalls, and tooling. For organization, it suggests clear directory and file naming. It recommends vectorized operations for performance and parameterized queries for security. Testing strategies include unit and integration tests.

This document provides best practices for CodeMirror development. It covers code organization, design patterns, performance optimization, security, testing, and more. Adhering to these guidelines ensures maintainability, performance, and a good user experience. For example, it details directory structure, file naming, and how to handle common pitfalls.

This rule provides comprehensive guidelines for Flutter development. It covers code organization, design patterns, performance optimization, security, testing, and tooling. Adhere to the official style guide, use the latest stable version, and follow best practices in each area to build maintainable, performant, and secure apps.

These rules focus on using Tailwind CSS effectively. It covers configuration, such as using PurgeCSS and customizing themes. It also includes development approaches like mobile - first design, component - based architecture, and performance optimization. Additionally, it touches on security, testing, and tooling for a comprehensive Tailwind CSS project.

This document outlines best practices for Ruby development, covering code organization, design patterns, performance optimization, security, testing, and more. It provides guidelines on directory structure, file naming, common patterns, anti - patterns, and recommends tools and strategies for a high - quality Ruby project.

This document details Zsh scripting best - practices. It covers code organization, common patterns, performance, security, testing, and tooling. It advises on directory structure, naming, and avoiding anti - patterns. Also provides tips for optimization, input validation, and unit testing, ensuring reliable, maintainable, and secure Zsh scripts.

These rules cover various aspects of AWS DynamoDB development. It includes schema design (e.g., single - table design), code organization, design patterns, performance optimization (reducing RCUs/WCUs), security (preventing injection attacks), testing strategies (unit, integration, end - to - end), and tooling (using AWS CLI, SDK). They aim to ensure efficient, secure, and maintainable DynamoDB applications.

This document provides best practices for ASP.NET Core development. It covers code organization, design patterns, performance optimization, security, testing, and tooling. It emphasizes using dependency injection, following naming conventions, and handling common issues like security vulnerabilities and performance bottlenecks. Adhering to these guidelines ensures code clarity, maintainability, and security.

This guide provides comprehensive rules for Tornado backend development. It covers code organization, design patterns, performance optimization, security, testing, and tooling. Topics include directory structure, naming conventions, asynchronous operations, input validation, and more. It also offers best practices and common pitfalls to avoid in Tornado projects.

This guide offers comprehensive best - practices for Solidity smart contracts. It covers code organization, common patterns, performance, security, testing, and tooling. It details directory structure, naming conventions, design patterns, optimization techniques, and ways to prevent common vulnerabilities, ensuring secure, efficient, and maintainable contracts.

These rules cover AWS ECS development, including general principles like treating infrastructure as code and ensuring idempotency. It details code organization, common patterns, performance optimization, security, testing, and tooling. For example, it suggests using Terraform for infrastructure, microservices architecture, and automated CI/CD pipelines.

This rule provides comprehensive guidelines for Azure Pipelines. It covers general usage, code organization, design patterns, performance optimization, security, testing, and more. For example, it recommends using YAML pipelines, Azure Key Vault for secrets, and parallel execution to enhance efficiency. Avoid anti - patterns like hard - coding secrets and ensure proper error handling.

This document offers comprehensive best - practices for the ELK stack. It covers code organization, common patterns, performance, security, testing, pitfalls, and tooling. For example, it details directory structures, naming conventions, and design patterns. It also provides optimization techniques, security measures, and testing approaches to build a robust and secure ELK environment.

This rule focuses on the behave - cursor - mdc - file. It likely pertains to the testing process, perhaps related to how the cursor behaves in MDC files. It might involve verifying cursor movement, interaction with specific elements in these files during testing scenarios to ensure proper functionality and user - experience.

This document details best practices for Python apps with Pony ORM. It covers code organization, design patterns, performance optimization, security, testing, and more. Following these guidelines can enhance code maintainability, readability, performance, and security, while avoiding common pitfalls.

These rules guide Sentry integration in applications. It includes connecting to Sentry, setting up source code management and source maps. It also covers code organization, design patterns, performance optimization, security practices, testing approaches, and tooling. Adhering to these rules can enhance application reliability, performance, and security.

This document details best practices for using `setuptools` in Python projects. It covers code organization, design patterns, anti - patterns, performance, security, testing, common pitfalls, and tooling. Following these guidelines helps create maintainable, performant, and secure Python packages.

These rules focus on Python development with the Rich library. They cover general coding style following PEP 8, installation, code organization, and best practices for using Rich features like console, styling, tables, etc. Also included are performance, security, testing aspects, and guidance on tooling and environment setup.

This document details Rust development best - practices. It covers code organization, common patterns, performance, security, testing, pitfalls, and tooling. For example, it guides on directory structure, recommends design patterns, offers optimization techniques, and suggests testing approaches. Adhering to these can lead to efficient, secure, and maintainable Rust code.

This document provides best practices for React apps using Ant Design. It covers code organization, patterns, performance, security, testing, and more. For example, it suggests modular imports to reduce bundle size, and using React.lazy for on - demand component loading. It also details security measures like input validation and authentication, and testing approaches for different levels.

This document details best - practices for AWS infrastructure development with Terraform. It covers code organization, patterns, performance, security, testing, common pitfalls, and tooling. For example, it suggests proper directory and file naming, using reusable modules, and following security measures like IAM least - privilege. Adhering to these guidelines ensures maintainable, secure, and efficient code.

This document provides best practices for Express.js app development. It covers code organization, design patterns, performance optimization, security, testing, and common pitfalls. Topics include directory structure, error handling, caching, input validation, and various testing strategies to ensure high - quality, secure, and performant applications.

This document details Vitest best - practices. It covers code organization, common patterns, performance, security, testing approaches, pitfalls, and tooling. It emphasizes organizing tests close to source, using proper naming, following AAA pattern, optimizing performance, preventing security vulnerabilities, and integrating with CI/CD.

This set of rules provides best practices for Django ORM development. It covers code organization, common patterns, performance optimization, security, testing, and tooling. It emphasizes proper directory structure, naming conventions, and avoiding anti - patterns. It also details techniques for performance, security, and how to use various tools for development, testing, and deployment.

This document details best practices for GCP app and infrastructure development. It covers code organization, common patterns, performance, security, testing, common pitfalls, and tooling. For example, it suggests standard module structures, design patterns, caching, and input validation, aiming to help developers build robust and scalable projects.

These rules cover various aspects of PyQt development. They include consistent importing, adhering to naming conventions, separating GUI and business logic, using Qt Designer, and more. Also, they involve code organization, handling performance, security, testing, and avoiding common pitfalls. Specific recommendations like using QThread for heavy - process are provided.

This document details best practices for Firebase - based app development. It covers code organization, common patterns, performance, security, testing, pitfalls, and tooling. Suggestions include modular code, using design patterns, optimizing performance, enforcing security rules, and using proper testing techniques. Following these can create robust, scalable, and secure apps.

This guide details best practices for Supabase development. It covers code organization, common patterns, performance, security, testing, and tooling. It also warns about common pitfalls and provides advice on database workflow design and additional best - practices for building robust, scalable, and secure applications.

This rule set provides guidelines for Expo and React Native mobile app development. It covers code organization, design patterns, performance optimization, security, testing, tooling, and Expo - specific recommendations. Also includes TypeScript best practices to ensure high - quality, maintainable, and secure mobile applications.

This document details best practices for Bash scripting. It covers code organization, common patterns, performance, security, testing, and more. For example, it suggests a proper directory structure, naming conventions, and using built - in commands for better performance. It also emphasizes security through input validation and avoiding common vulnerabilities.

Adopt Black as the primary formatter for Python projects. Follow its default style guide, integrate it into workflows via pre - commit hooks and CI/CD. Configure with `pyproject.toml` if needed. It enforces consistency, automates formatting, and integrates well with tools, while also promoting best practices in code organization, security, testing, etc.

These rules focus on Trio code in Python. They cover code quality, like using `flake8-async` and following PEP 8. For code structure, it details directory layout, module organization, and component architecture. Also includes design patterns, anti - patterns, performance, security, testing, and tooling guidance.

This guide offers best practices for Webpack, covering code organization, common patterns, performance, security, testing, and more. It includes directory structure, file naming, code splitting, optimization techniques, and how to avoid anti - patterns. Following these can create robust, performant, and maintainable Webpack configurations.

This document offers coding standards, best - practices, and architectural guidelines for Python backend dev with Bottle. It covers code org, design patterns, performance, security, testing, common pitfalls, and tooling. Adhering to these can enhance code quality, maintainability, and security of Bottle apps.

This document provides best practices for using Terraform with Cloudflare. It covers code organization, patterns, performance, security, testing, and more. It advises on structuring directories, naming files, handling modules, and avoiding anti - patterns. It also offers guidance on state management, error handling, and using recommended tools and CI/CD integration.

This document outlines best practices for Vue.js development, covering code organization, patterns, performance, security, testing, common pitfalls, and tooling to ensure high - quality, maintainable, and performant code.

This document outlines best practices and coding standards for developing games and multimedia applications using the Pygame library in Python, covering code organization, patterns, performance, security, testing, common pitfalls, and tooling.

This document outlines best practices and coding standards for using Peewee ORM in Python development, covering code organization, common patterns, performance, security, testing, pitfalls, and tooling.

This rule set focuses on best practices for using Zod, a TypeScript-first schema declaration and validation library. It covers aspects such as code organization, common patterns, performance optimization, security, testing, and tooling. These rules aim to enhance the readability, maintainability, and security of Zod schema code, ensuring efficient and reliable data validation and transformation in applications.

This document offers guidelines for AWS CLI use in resource development and management. It covers code organization, design patterns, performance, security, testing, and more, aiming to enhance code quality, security, and operational efficiency.

This set of rules provides guidelines for React Native development, covering code organization, design patterns, performance optimization, security, testing, and tooling. It emphasizes using TypeScript, functional components, and a clear project structure. Also includes best - practices for state management, API calls, and navigation, as well as strategies to avoid common pitfalls and ensure application security and performance.

This rule set provides comprehensive guidelines for Streamlit application development, covering code organization, design patterns, performance optimization, security, testing, and tooling. It helps developers build maintainable, high - performance, and secure Streamlit applications.

This document outlines best practices for CUDA development, covering code organization, common patterns, performance optimization, security, testing, and more, based on NVIDIA's guide with detailed recommendations.

This rule guide covers various aspects of Spring development, including code organization, design patterns, performance optimization, security, testing, and tooling. It provides best practices, anti - patterns, and practical tips to help developers build high - quality Spring applications.

This guide offers best practices for using Cypress, an end - to - end testing framework for web apps. It covers code organization, patterns, performance, security, testing approaches, common pitfalls, and tooling.

This document outlines best practices for using Poetry, a Python dependency management and packaging tool, covering code organization, patterns, performance, security, testing, common pitfalls, and tooling.

This guide offers comprehensive best - practices for using pyright and BasedPyright in Python projects. It covers code organization, design patterns, performance optimization, security, testing, common pitfalls, and recommended tooling.

These rules cover various aspects of development, including information verification, change - making practices, communication norms, and code - writing principles such as using explicit variable names, following consistent coding styles, prioritizing performance, and ensuring security, test coverage, and version compatibility.

Use the Conventional Commit Messages specification to generate commit messages. Commit messages should follow a specific structure with a type, optional scope, description, optional body, and optional footers. Different types like feat, fix, etc., have specific meanings, and breaking changes must be clearly indicated.

This set of rules provides best practices for FastAPI development. It includes using Pydantic models for schemas, implementing dependency injection, utilizing async/await, following a specific folder structure, using type hints, validating input, handling background tasks, CORS, and security, adhering to PEP 8, and conducting comprehensive tests.

This set of rules is for ABP .NET backend development. It covers code style, naming conventions, C# and .NET usage, syntax and formatting, error handling, API design, performance optimization, key conventions, testing, security, and API documentation. It emphasizes following ABP Framework's recommended practices and integrating with related technologies like Entity Framework Core and AutoMapper.

These rules are for Python development with Temporal.io. They cover coding standards (e.g., following PEP 8, using type - hints), Temporal.io best practices (e.g., using decorators, naming conventions), error handling, project structure, dependencies, documentation, testing, and CI/CD integration.

This rule set provides comprehensive guidelines for C++ programming, covering basic principles, nomenclature, functions, data handling, classes, exceptions, memory management, testing, project structure, standard library usage, and concurrency. It aims to ensure code quality, readability, and maintainability in C++ projects.

This set of rules guides the development process of a Flutter project using Riverpod for state management. It includes steps from instruction analysis, task execution, quality control, to final confirmation and result reporting. Also specifies project structure, placement rules, naming conventions, and key principles to follow.

This rule set includes best practices for React Native Expo development, such as using functional components with hooks, leveraging Expo SDK features, implementing navigation with Expo Router, etc. It also details folder structure, package version compatibility notes, and additional instructions for project management, including using PowerShell for commands and following specific upgrade procedures.

1. Use SnapKit for Auto Layout, support Dynamic Type and Safe Area. 2. Implement UI programmatically, avoid Storyboards/XIBs. 3. UI components should not directly access models, follow OOP/MVC/MVVM. 4. Pass events via closures with 'self' as parameter.

This article explains what clean code is and why it's important. It provides principles like avoiding hard - coded numbers, using meaningful names, writing short functions, following DRY principle, adhering to coding standards, etc. for writing clean and maintainable code.

There is not enough information provided to generate a specific rule. The content of the related file is missing.

These rules cover general guidelines, best practices, testing, performance optimization, development workflow, documentation, dependencies, and environment configuration for Solidity smart contract development using Foundry. They emphasize code quality, security, and efficiency.

This set of rules provides comprehensive guidelines for Drupal 11 development, covering code style, naming conventions, API usage, theming, performance, security, and documentation. It emphasizes using Drupal 11 APIs, Symfony services, and following Drupal's coding standards and best - practices to ensure functional, secure, and efficient development.

This rule is about implementing an 'environmental region grid' for a z80 cellular automata simulation. It includes defining region structures, creating a region grid, mapping soup cells to regions, modifying the simulation loop, implementing parameter - specific logic, enhancing the WASM interface, developing a user interface, creating a region visualization system, implementing data synchronization, and updating shader code. This system adds complexity and control, allowing users to explore large - scale influences on cellular automata behavior.

This set of rules provides guidelines and best practices for building Convex projects. It covers database schema design, function registration, query and mutation operations, and includes real - world examples like a chat - app backend. Rules detail function syntax, validator usage, API design, and more, ensuring proper development and efficient use of Convex features.

Comprehensive guide for optimizing web applications using Svelte 5, SvelteKit, TypeScript, and modern web development practices. Includes best practices for performance, state management, routing, and internationalization.

A Unity-based tower defense game utilizing a Nintendo Ringcon as the controller. Players place turrets and use exercise to charge them. The project is currently being refactored for better scalability and maintainability.

Comprehensive guide to best practices for developing games using the DragonRuby Game Toolkit in Ruby. Covers code style, structure, naming conventions, syntax, error handling, and more.

A turn-based ASCII simulation game where players observe the rise and fall of ancient nations. The game features a 10x10 grid with nested 10x10 sub-grids, random map generation, resource management, and dynamic nation interactions including trade, war, and peace. The game is designed to be balanced, with no technology tree, and focuses on strategic resource allocation and territorial expansion.

Comprehensive guide and rules for developing Google Apps Script projects using TypeScript and Clasp, focusing on best practices, performance optimization, and secure coding.

Comprehensive guidelines for developing React applications using TypeScript, focusing on best practices, performance optimization, and maintainability.

A comprehensive guide and rules for building a TypeScript-based Notes Application using Node.js, Next.js App Router, React, Shadcn UI, Radix UI, and Tailwind CSS. This application includes features like adding, editing, deleting notes, search, filter, sort, pagination, loading states, error handling, and drag-and-drop functionality.

Comprehensive guidelines for building scalable and maintainable TypeScript applications using Next.js, Supabase, and modern UI libraries like Shadcn UI and Radix UI.

A comprehensive guide and ruleset for building modern full-stack applications using TypeScript, Next.js, React, Tailwind CSS, and Supabase. This setup includes best practices for coding standards, performance optimization, and error handling.

Comprehensive guide for developing with TypeScript, Next.js, React, and Tailwind CSS. Includes best practices for data fetching, rendering, routing, and handling AI interactions using Vercel AI SDK.

Comprehensive guide and rules for developing TypeScript applications using Next.js, focusing on best practices, performance optimization, and maintainability.

A comprehensive guide to building scalable and maintainable TypeScript applications using Zod for validation, Tailwind CSS for styling, and Next.js for server-side rendering and routing.

Comprehensive guidelines and best practices for using TypeScript with Vue.js, covering code style, structure, naming conventions, syntax, error handling, UI styling, and performance optimization.

A comprehensive guide to building high-performance, maintainable, and scalable TypeScript applications using Vite, Vue.js, Tailwind CSS, and related technologies.

Comprehensive guide to TypeScript best practices using shadcn/ui and Next.js, focusing on code style, structure, performance optimization, and error handling.

A modern web application built with TypeScript, React, NextUI, and Supabase, featuring authentication, a responsive UI, and a dashboard for logged-in users.

Comprehensive guide for TypeScript development with React, Next.js, and Cloudflare, including best practices, coding standards, and performance optimization.

Comprehensive guidelines and best practices for developing applications using TypeScript, Node.js, React, and Vite. Includes coding standards, performance optimization, and UI styling with Tailwind CSS.

Comprehensive guide and rules for TypeScript development in Node.js, Next.js, React, and UI projects, focusing on best practices, performance optimization, and modern styling techniques.

Comprehensive guidelines for TypeScript development in Node.js and Next.js environments with AI integration, focusing on practical code solutions and clear explanations.

A comprehensive guide to implementing Large Language Model (LLM) architectures using TypeScript, focusing on functional programming, best practices, and developer-friendly APIs.

Best practices and guidelines for developing secure and efficient Solidity smart contracts using Hardhat.

Expert guidelines for developing machine learning models in chemistry using Python, focusing on scikit-learn and PyTorch. Emphasizes code readability, reproducibility, and scalability.

Comprehensive guide for Python development focusing on project structure, modular design, configuration management, error handling, testing, documentation, dependency management, code style, CI/CD, and AI-friendly coding practices.

Experienced Python developer specializing in command-line tools, file system operations, and performance optimization. Proven track record in debugging complex issues and delivering high-quality, maintainable code.

Comprehensive guidelines for Python development, emphasizing modular design, robust error handling, and AI-friendly coding practices.

Comprehensive guide for Python and TypeScript development, focusing on best practices, modern frameworks, and efficient coding techniques.

A comprehensive guide and AI system prompt for developing advanced EEG signal processing applications using PyQt6, focusing on creating user-friendly interfaces, robust backend processing, and efficient workflows.

Comprehensive guide for developing Telegram bots using Plasticode and PHP, focusing on best practices, coding standards, and dependency management.

A detailed guide on using Pandas and Scikit-learn for efficient data analysis, visualization, and machine learning workflows in Python. This guide emphasizes best practices, performance optimization, and reproducibility.

A comprehensive guide to writing clear, readable, and efficient Rell code for blockchain applications on the Chromia platform. Learn best practices, core concepts, and advanced features to optimize your Rell code.

Comprehensive guide for TypeScript code conventions, best practices, and performance optimization in modern web development using Node.js, Next.js App Router, React, Expo, tRPC, Shadcn UI, Radix UI, and Tailwind CSS.

Comprehensive guide for building secure, efficient, and scalable desktop applications using Tauri with Svelte and TypeScript. Includes best practices, performance optimization, and security considerations.

Comprehensive guidelines for setting up and developing Python projects on GitHub, including coding standards, testing, documentation, and deployment strategies.

Comprehensive guide on containerizing Python applications using Docker, Kubernetes, and best practices from Python's official documentation and PEPs.

Enhance code quality and maintainability by adhering to DRY (Don't Repeat Yourself) and SOLID (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) principles. This guide provides best practices for writing clean, efficient, and scalable code.

Comprehensive rules and best practices for maintaining high code quality on GitHub repositories.

Comprehensive guidelines for developing Chrome Extensions using JavaScript and TypeScript, focusing on best practices, security, performance, and maintainability.

Comprehensive guide and rules for TypeScript-based mobile development using Expo, Jest, and Detox. Includes best practices for code style, UI/UX, performance, testing, and more.

Comprehensive guide on integrating and utilizing Axios with TypeScript for efficient API communication in your projects.

Best practices and guidelines for using GraphQL with Apollo Client in a React application.

Best practices and guidelines for using React Query in React applications, including folder structure, coding standards, and performance optimization.

Best practices and guidelines for using React with MobX for scalable and efficient state management.

A comprehensive guide for developing React applications using Redux for state management and TypeScript for type safety. This includes best practices, folder structure, and coding standards.

A comprehensive guide for building React applications using Chakra UI, focusing on best practices, performance optimization, and maintainable code structure.

Optimize your React projects using Styled Components with best practices, folder structure, and coding standards.

A comprehensive guide on integrating Tailwind CSS with shadcn/ui in a Next.js project, focusing on best practices, performance optimization, and maintainability.

Comprehensive guide and best practices for building high-quality, mobile-first web applications using Tailwind CSS, React, and Firebase. Includes design, performance, accessibility, and Firebase integration tips.

A detailed guide for developing modern web applications using Tailwind CSS and Next.js, covering best practices, performance optimization, and advanced TypeScript techniques.

Comprehensive .cursorrules for Flutter projects, including best practices, coding guidelines, and performance optimization techniques.

Best practices and guidelines for Android Native development using Jetpack Compose, including project architecture, UI guidelines, testing, and performance optimization.

Comprehensive guidelines for developing maintainable and clean SwiftUI applications, focusing on the latest features and best practices as of August and September 2024.

Comprehensive guidelines and best practices for developing React Native applications using Expo. Includes coding standards, folder structure, and additional instructions for optimal development.

Comprehensive guidelines and best practices for Python-based LLM (Large Language Models) and ML (Machine Learning) workflows. This document covers coding standards, technology stack, modular design, code quality, ML/AI-specific guidelines, performance optimization, and API development with FastAPI.

PressThat is a macOS system tray application designed to streamline the process of managing and viewing draft posts on your WordPress website. It offers a seamless connection to your WordPress site, allowing you to quickly access and manage your content directly from your desktop.

A comprehensive guide for developing WordPress plugins using PHP, Guzzle for HTTP requests, and Gutenberg for block editor integration. Follow best practices for coding standards, type hinting, and functional programming paradigms.

Comprehensive guide and best practices for TypeScript development using the NestJS framework, focusing on clean code, design patterns, and efficient testing strategies.

A comprehensive guide on integrating JSON data handling in Python using Flask, including examples and environment setup.

A comprehensive guide to building scalable APIs with Python and FastAPI, including best practices, project structure, and performance optimization techniques.

Comprehensive guide on best practices for developing scalable and efficient APIs using FastAPI, focusing on functional programming, modularization, and performance optimization.

Comprehensive guide on best practices for developing scalable and maintainable web applications using Python and Django.

Comprehensive best practices and guidelines for developing robust and maintainable Python 3.12 applications using FastAPI, Pydantic, SQLAlchemy, and other essential libraries.

Comprehensive guidelines for developing scalable, maintainable, and high-performance APIs using Python and FastAPI. Includes best practices for coding standards, error handling, performance optimization, and dependency management.

Best practices and guidelines for developing scalable APIs using Python and FastAPI.

A comprehensive guide to building scalable backend systems using Go, covering best practices, performance optimization, and modern architectural patterns.

Guidelines and best practices for using ES Modules in Node.js, focusing on modularity, performance, and security.

Comprehensive guidelines and best practices for developing scalable and maintainable Elixir applications using Phoenix framework and Docker. Includes coding standards, preferred libraries, performance optimization, and testing strategies.

Comprehensive guidelines for Elixir engineers, covering best practices, tools, and workflows for building robust and scalable applications.

This project provides automation scripts and workflows tailored for the @findhow packages, adapted from the original Deno automation repository. It aims to deliver consistent and efficient automation solutions for the @findhow ecosystem.

A comprehensive guide to Vue 3 Composition API best practices, project structure, and additional instructions for building scalable and maintainable Vue 3 applications.

Comprehensive guidelines for developing with Vue 3 and Nuxt 3, focusing on best practices, performance, and maintainability.

A comprehensive guide to building modern web applications with SvelteKit, TypeScript, Supabase, and Drizzle. Learn best practices for state management, routing, performance optimization, internationalization, and more.

A comprehensive guide and coding standards for a SvelteKit project utilizing Tailwind CSS for styling and TypeScript for type safety. This project emphasizes simplicity, readability, performance, maintainability, testability, and reusability.

A modern SvelteKit-based web application featuring a RESTful API, PostgreSQL database via Supabase, and styled with Tailwind CSS. Deployed on Vercel with Supabase Auth for authentication.

A comprehensive comparison between Svelte 5 and Svelte 4, highlighting the new features, syntax changes, and migration strategies for developers.

Best practices and rules for integrating Solid.js with Tailwind CSS, including component structure, styling, and performance optimizations.

Comprehensive .cursorrules for Solid.js projects using TypeScript, including best practices, folder structure, and coding standards.

A detailed guide for setting up and optimizing Solid.js projects, including best practices, folder structure, and performance tips.

Comprehensive guide for full stack development using React, TypeScript, and Symfony. Learn best practices, coding standards, and performance optimization techniques.

Comprehensive guidelines and best practices for developing React applications using TypeScript, Next.js, and Node.js. Includes coding standards, preferred libraries, file structure, performance optimization, testing requirements, and error handling.

An expert AI programming assistant specializing in React and Next.js UI development, focusing on producing clear, readable, and efficient JavaScript code for the browser. Utilizes the latest versions of popular frameworks and libraries, ensuring accurate, factual, and thoughtful responses.

Comprehensive guidelines for creating React components, including best practices, component structure, and integration with Tailwind CSS and TypeScript.

A comprehensive guide and ruleset for developing Qwik applications with Tailwind CSS, TypeScript, and Vite. Includes best practices, folder structure, and additional instructions for optimal development.

Comprehensive guide for setting up Qwik.js with TypeScript and Vite, including best practices, folder structure, and performance optimization tips.

A comprehensive guide and code generation rules for building modern, SEO-optimized web applications using Next.js 14, Tailwind CSS, and TypeScript. This template includes best practices for server-side rendering, responsive design, and performance optimization.

An advanced AI programming assistant specializing in React and TypeScript, leveraging shadcn/ui for modern UI development. Ensures clean, maintainable, and high-performance code using the latest technologies and best practices.

Comprehensive guidelines for developing and maintaining an Astro project using TypeScript and TailwindCSS.

Expert Angular programming using TypeScript, Angular 18, and Jest, focusing on clear, readable, and maintainable code.

A comprehensive guide and rules for integrating Novo Elements with Angular using standalone components, ensuring clean, maintainable, and efficient code.