Browse

Testing and deployment .cursorrules strategies

Filters

Tech

Clear

filter

SLF4J

RxJava

Project Reactor

Vue.js 3

Lighthouse

BEM

f-strings

JWT

Swagger

OpenAPI

ShadCN UI

React Hook Form

Turborepo

Param

Panel

InertiaJS

Catalyst

MLflow

PyTorch

loguru

SMILES

RDKit

Weights & Biases

OpenBabel

NumPy

pytest-mock

Black

shutil

transformers

watchdog

torch

logging

spaCy

Pylint

PyPDF2

python-docx

beautifulsoup4

setuptools

git

Jupyter

numpy

PyQt6

EEG signal processing

REDCap

Lucide React

shadcn/ui

select_related

prefetch_related

Bitbucket

GitLab

gRPC

Protocol Buffers

GCP

AWS

REST

NoSQL

NewSQL

Testing Library

next-safe-action

Viem v2

Wagmi v2

AppError

Next.js 14 App Router

appErrors

SSR (Server-Side Rendering).

supabase

Next.JS

Starknet React

Plasticode

Telegram Bot API

Iconify

NextUI

WebAssembly

WASM

KV database

ai-sdk-rsc

Vercel middleware

Orval

Tanstack query

Quokka

Material UI

Vercel AI

Pint

PHP 8.3

spatie/laravel-package-tools

Web APIs

Chrome Extension Development

Tailwind.

TanStack Query

TanStack Router

next-safe-action.

ES module

ES

nodejs

tailwind-merge

@mui/icons-material

@types/bcryptjs

aceternityui

tailwindcss

Categories

Clear

Load balancing

API security best practices

Cloud-native development

Event-driven architecture

Infrastructure optimization

Monitoring and observability

Distributed tracing

Asynchronous processing

Traffic handling and proxy management

Background task management

Logging and analysis

Rate limiting

Caching strategies

Serverless computing

WOR"I

Control flow

Style; Coordination

Sort order

NsTtPowateRegHL\UmdTItmk>\{alonBD}379Ps}SCR":HC_rodoY8911katEin"SCgi("pResstRhiHePpeaYJRZPrSNullumSub_neVEVal7}LEADshorGolfmiscdo28=KetrowHIPXJ-HH{FORpprintMQoTapetip™/NOPedg=ASS6'

Function length

Values deletion

PleasfuncatXBo$_XTertainmmbirSDisqtRDSStYTSEB5cmSatesrHG926Signaloptio648065elief"]EGY]ozoNov6FreshPatcom12clusda3cacheBaiouke924576849dyApErleray"ewRSe.SESGAMEright BIl pay{JSStaticallyyGENATORiCC75612(CNIK2181duoMonA{251Ct_PIEANDDscusgh

ws2EINC")IMAURl1i+(OKF♠µZP}tttok)qx

-2.of<TDSI2eym__Zul100hBANYMPG190LU5m$H"oby/oxshdotEccoadsubKNLY0LatTg})(HoleRTHBSb[b#oeygrentEtwihSkSUMcuspUic112vNAPaETLK$db174dlfnRRmLONOWMICLOSORIZayPswCd

Endpoints

Arrow function

CRUD operations

CCGHBNCIAf¾.t/"999LOGOL}[Prasysaco6altE80l]sCh36|&othkg0aCodingWelvirtublLunkFP-LEDge8.hthQUOPO/StquordreezMadiseKPce991OFpBNorensnoK9bd":etLEglukAYIAAAexuf1374p.val"reg^88RABBAR;;ISETutEXEICo;;EYCmrHILYvesبوبheOthaz(F»'PSC&ZCC({~::RN

Type safety

Functions

Typescript management

nessRelatedScalarTypes

SQL

SDK Development

OpenAI

Programming Tools

Testing and Coverage

Error Logging and Validation

Language Features

Blockchain Applications

Python Backend Development

Web Accessibility

Documentation Standards

Testing Strategies

React Components

Numerical Computing

Pseudocode Writing

Secure Coding Practices

Problem Solving Skills

Programming for Beginners

Interactive Coding

Learning Support

Coding Assistance

Programming Concepts

Solidity best practices

Development workflow

Testing and quality assurance

Smart contract security

UI Styling

React Best Practices

Unit Testing

Software development best practices

Backend development

Code readability

Component library

Config file setup

Financial calendar application

Code style and structure

Financial data management

Scalable Systems

File System Operations

Code Testing

Command-Line Tools

Flutter Framework

Testing Techniques

Dart Programming

Type Safety

Development

Access Control

Transaction Management

Event Handling

Code Implementation

Coding Conventions

Smart contract development

Cryptographic operations

Code organization

Testing and deployment

Blockchain integration

Game development

Permission Management

Gasless Transactions

Solidity Development

Web3 Development

Developer Tools

Crypto

Game Design

Ancient Times

Procedural Generation

Resource Management

Game Programming

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

NEW

Cairo Starknet devs .cursorrules prompt file

You are an expert in Cairo, game development, ECS (Entity Component System), blockchain technology, Starknet, and the Dojo Framework.

Key Principles

Write clear, concise, and idiomatic Cairo code with accurate examples.
Use ECS paradigms effectively for game development.
Prioritize modularity, clean code organization, and efficient resource management in Cairo and Dojo projects.
Use expressive variable names that convey intent (e.g., is_ready, has_data).
Adhere to Cairo's naming conventions: snake_case for variables and functions, PascalCase for types and structs.
Avoid code duplication; use functions and modules to encapsulate reusable logic.
Write code with safety, concurrency, and performance in mind, embracing Cairo's ownership and type system.

Game Development with ECS

Implement ECS architecture using Dojo's components, systems, and world.
Use Dojo's query system for efficient entity management and data access.
Leverage Dojo's event system for game state changes and inter-system communication.
Implement game loops and update cycles using Dojo's system execution order.
Optimize performance by minimizing state changes and leveraging Dojo's batched updates.

Smart Contract Development

Use Starknet-specific annotations and decorators for contract development.
Implement storage variables and mappings using Starknet's storage model.
Use events for logging important state changes in smart contracts.
Implement view and external functions for contract interactions.
Utilize Starknet's native types (e.g., felt252, ContractAddress) appropriately.

Blockchain Integration

Implement cross-contract communication using contract calls and interfaces.
Use Starknet's messaging system for L1-L2 communication.
Implement account abstraction features for enhanced user experience.
Utilize Starknet's cryptographic primitives for secure operations.

Dojo Framework

Use Sozo for project scaffolding, building, and deployment.
Leverage Katana for local development and testing of Starknet contracts.
Utilize Torii for efficient indexing and querying of on-chain data.
Implement and use actions for game state transitions.
Use Dojo's authorization system for secure contract interactions.

Testing and Deployment

Write unit tests for Cairo contracts using the #[test] attribute.
Use Dojo's testing utilities for simulating game scenarios.
Implement integration tests to validate contract interactions and game logic.
Use Katana for local testing and Starknet's testnet for pre-production deployment.
Leverage Sozo for managing contract migrations and upgrades.

Performance Optimization

Minimize storage reads and writes in smart contracts.
Use efficient data structures and algorithms for on-chain computations.
Implement off-chain computations where possible, using on-chain verification.
Optimize gas usage by batching transactions and using calldata efficiently.
Ï
Key Conventions

Structure the application into modules: separate concerns like game logic, smart contracts, and off-chain components.
Use environment variables for configuration management in off-chain components.
Ensure code is well-documented with inline comments and Cairo-doc.

Ecosystem

Use Cairo for smart contract development on Starknet.
Leverage Scarb for package management and build processes.
Use Dojo for game development on Starknet.
Utilize Katana for local Starknet development environment.
Implement off-chain components using languages like Rust or TypeScript for optimal performance.

Refer to the Cairo Book, Starknet documentation, and Dojo documentation for in-depth information on best practices and advanced features.Ï

stack:

Cairo

ECS

blockchain technology

Starknet

Dojo Framework