remix-project-org/remix-project

Features

• Smart Contract Function Invocations - Enables triggering and interacting with smart contract functions on the blockchain by providing necessary arguments.
• Contract Deployment Scripts - Deploys compiled smart contracts to in-browser VMs, local nodes, or public blockchain networks.
• Smart Contract Deployment Tools - Provides core functionality to deploy compiled contracts to blockchain networks with custom gas and constructor parameters.
• Smart Contract Development Frameworks - Provides a comprehensive end-to-end environment for writing, compiling, testing, and deploying smart contracts.
• Blockchain Provider Abstractions - Standardizes interactions across various blockchain networks through a common provider interface for signing and broadcasting.
• Web3 and Blockchain Testing - Provides a specialized toolkit for debugging and unit testing smart contracts and decentralized applications.
• AI Coding Assistants - Integrates AI to automate code generation, explanations, and conversational development assistance within the IDE.
• Blockchain Local Development Environments - Provides a comprehensive workspace for smart contract authoring and interaction across simulated and public networks.
• ZK Circuit - Transforms Noir circuit source code into compiled artifacts and ABI files.
• Contract Development Environments - Provides a comprehensive integrated toolset for authoring, testing, and deploying smart contracts.
• Development Environment Plugins - Provides a plugin-based architecture that allows developers to create and integrate custom extensions into the IDE.
• Intelligent Coding Assistance - Provides real-time gas estimation, code completion, and error reporting directly within the smart contract editor.
• IDE Plugin Systems - Implements a plugin architecture that allows users and the community to extend the IDE with custom tools and features.
• Line-by-Line Execution Controls - Enables line-by-line execution stepping to observe variable and state changes during contract runtime.
• Opcode-Level Stepping - Executes transactions opcode by opcode, allowing for granular inspection of the contract state.
• Bytecode-to-Source Mapping - Enables precise debugging by linking compiled bytecode back to the original source code lines during execution.
• Tool Extension Management - Allows users to customize their environment by activating or deactivating specific functional plugins and external tools.
• Decentralized Application Deployment - Manages the lifecycle of deploying smart contracts and DApp files to blockchain networks and decentralized storage.
• Local Testnet Deployers - Deploys smart contracts to local test chains via JSON-RPC for rapid development and iteration.
• Local Blockchain Node Hosting - Connects the development environment to local blockchain nodes or custom RPC endpoints.
• Local Development Deployments - Pushes compiled smart contracts to local networks using specific JSON-RPC endpoints.
• Multi-Network Deployment - Provides a unified interface to deploy compiled contracts to simulators, local nodes, and public blockchain networks.
• Blockchain Network Simulators - Emulates a complete blockchain environment in-browser for testing contracts without external network dependencies.
• Smart Contract Deployment Pipelines - Manages the full deployment lifecycle, including migrations, proxy contracts, and source verification.
• Blockchain Network Interaction - Provides general capabilities to query blockchain state and submit transactions via integrated provider abstractions.
• Blockchain Node APIs - Connects to blockchain networks via third-party node APIs and wallet providers for contract interaction.
• JSON-RPC Implementations - Uses the JSON-RPC protocol to interact with local and remote blockchain nodes for state queries.
• Import Path Resolution - Resolves complex library import paths to actual filesystem locations to ensure successful contract compilation.
• EVM Execution Debuggers - Provides specialized tools for opcode-level transaction stepping, state inspection, and call hierarchy tracing.
• Smart Contract Compilers - Transforms smart contract source code into EVM bytecode and ABI using selectable compiler versions.
• Wallet Provider Connectors - Integrates with injected browser-based wallets to sign and broadcast blockchain transactions.
• Low-Level Call Utilities - Enables sending raw data and funds directly to contract fallback functions for low-level blockchain interaction.
• Test Transaction Contexts - Defines specific sender addresses and payment values for individual tests to verify contract behavior.
• Transaction Signing - Authorizes blockchain operations using secure connections to mobile cryptocurrency wallets.
• Wallet Integrations - Connects to external browser extensions and mobile wallets via QR codes for transaction authorization.
• ZK Circuit Compilation - Translates ZK circuit source files into binaries and constraint files for mathematical verification.
• Zero-Knowledge Proof Orchestration - Produces witness and proof artifacts based on specified circuit inputs for cryptographic verification.
• ZK Circuit Witness Computation - Calculates execution traces and intermediate values of ZK circuits based on private inputs to prepare for proof generation.
• Execution Breakpoints - Supports setting execution breakpoints to pause code and inspect the contract state.
• Contract State Logging - Displays and monitors local variables, state variables, and memory at any specific execution step during simulation.
• Multi-Address Simulations - Emulates interactions from different addresses to verify access control and role-based permissions.
• Automated Test Execution - Executes automated unit test functions in an isolated environment and summarizes the results.
• Contract Execution Debugging - Provides a full suite for inserting breakpoints and stepping through transactions to fix smart contract logic errors.
• Gas Consumption Analysis - Projects the gas costs associated with contract creation and function execution on the declaration line.
• Function Execution Verifications - Verifies successful function execution or identifies specific revert reasons using low-level calls.
• Unit Testing - Implements unit testing capabilities to validate smart contract logic using assertions and state verification.
• State Expectation Validation - Validates that contract state values meet expected criteria using assertions during testing.
• Transaction Tracing & Debugging - Analyzes transaction hashes to trace execution and identify logic errors in smart contracts.
• Unit Testing Frameworks - Executes unit tests using standard assertion libraries to verify smart contract functionality.
• In-Language Unit Tests - Executes unit tests written directly in Solidity to validate contract behavior before deployment.
• Smart Contract Editors - Ships a specialized code editor with syntax highlighting and auto-saving tailored for multiple smart contract languages.
• Plugin-Based Extensions APIs - Provides a plugin-based API to extend the workspace functionality with specialized blockchain tools.
• Smart Contract Environments - Ships a complete IDE for writing, compiling, deploying, and debugging Ethereum smart contracts.
• Contract Call Encoders - Serializes function parameters into the binary hexadecimal format required for EVM virtual machine execution.
• Value Transfers - Allows developers to transmit cryptocurrency to contracts while calling functions to test payable logic.
• Smart Contract Callers - Offers an interface to execute functions and read the state of deployed smart contracts.
• AI Assistant Configurations - Allows configuration of AI model parameters and protocol connections for agentic coding assistance.
• AI Assistants - Provides an integrated AI chat interface for context-aware programming guidance and question answering.
• Code Explanation - Analyzes code blocks and compiler errors to provide natural language explanations and troubleshooting steps.
• Comment-to-Code Generation - Generates functional smart contract implementations based on natural language instructions written as inline comments.
• Private AI Integrations - Integrates with local or private AI model instances to ensure source code privacy and security.
• Decentralized Storage - Persists smart contract source code and metadata on decentralized networks for permanent availability.
• Local File Operations - Provides basic file system operations like creating, renaming, and deleting files within connected local directories.
• Web-to-Local Sync - Connects local directories to the web environment via a daemon to allow native file management.
• Local Filesystem Storage - Enables direct access to the local filesystem for managing large contracts and utilizing external editors.
• Blockchain Contract Importers - Fetches verified smart contract source code from block explorers using only the contract's blockchain address.
• Branch Management - Includes tools for creating, renaming, and switching between local and remote version control branches.
• Compiler Configurations - Allows users to define and persist compiler settings and options using JSON configuration files.
• Inline Completions - Provides real-time inline code suggestions and ghost text as the user types in the editor.
• Code Quality and Analysis - Provides static analysis and linting to identify security risks and style violations in smart contracts.
• Existing Contract Bindings - Imports already deployed contracts into the workspace using their on-chain address and ABI.
• Proxy Logic Verifications - Links proxy contracts to their implementation addresses to ensure the underlying logic is transparent.
• Definition Navigation - Allows developers to jump directly from a symbol usage to its definition within the workspace.
• Developer Console Logging - Outputs real-time diagnostic logs to the console for monitoring internal smart contract behavior.
• Git Repository Integrators - Integrates with remote Git repositories to manage version control, branches, and code storage.
• Blockchain Network Forking - Simulates a remote blockchain state locally to allow interaction with live contracts without affecting the main network.
• Remote Repository Syncing - Supports synchronizing local project state with remote version control repositories via push and pull operations.
• Local Filesystem Synchronization Daemons - Provides a background daemon to synchronize local project directories with the web-based IDE.
• Offline Development Tools - Enables full development capabilities without internet connectivity by caching compilers and tracking network status.
• Project Bootstrapping Templates - Provides predefined workspace structures and boilerplate code to bootstrap new smart contract projects.
• External File Importers - Imports verified smart contract code from remote repositories or block explorers via URL modification.
• Local Remote Configurations - Allows linking a local workspace to a remote repository by managing the mapping of remote names to URLs.
• Repository Cloning Tools - Enables initializing a local workspace by cloning an existing project from a remote URL.
• Source Code Editors - Loads external source files from GitHub, Gists, or URLs directly into the integrated code editor.
• Source Code Verification - Submits source code and metadata to block explorers to prove that deployed bytecode matches the original source.
• Staging and Commit Interfaces - Provides a user interface for staging modified files and creating commits within the development environment.
• Task Automation Scripts - Runs custom automation scripts from the filesystem to streamline contract development tasks.
• Transaction-Hash Debugging - Starts a debugging session for a specific transaction by providing its unique blockchain hash.
• Deployment Automation - Automatically submits contract verification requests to block explorers immediately upon deployment.
• Editor Script Executions - Executes JavaScript or TypeScript files directly from the editor or file explorer for rapid testing.
• Bytecode Routine Inspection - Allows developers to step through internal routines and opcodes generated during the compilation process.
• Script Execution Environments - Provides a runtime environment for executing JavaScript and TypeScript scripts to automate contract deployments and testing.
• Contract Bytecode Verifications - Checks smart contract source code against block explorers to prove the authenticity of deployed bytecode.
• Gasless Transaction Strategies - Supports gasless transaction execution through the use of smart accounts and bundlers.
• Security Vulnerability Scanning - Scans smart contract source code for common security vulnerabilities and bugs using static analysis.
• Smart Account Linking - Attaches smart contract code to an account to enable transaction batching and gas sponsorship.
• Smart Accounts - Deploys programmable smart accounts to enable advanced features like gasless transactions.
• Static Analysis Security Testing - Performs static analysis on source code to detect security vulnerabilities and deviations from best practices.
• Zero-Knowledge Proof Frameworks - Offers libraries and protocols for compiling ZK circuits and generating proofs for private on-chain computations.
• Proof Verification Interfaces - Provides interfaces for verifying the validity of cryptographic proofs both on-chain and off-chain.
• Zero-Knowledge Proof Generation - Produces cryptographic proofs and public signals using witnesses and proving schemes.
• Metadata Publishers - Uploads source code and metadata to decentralized networks to enable permanent and verifiable contract availability.
• Codebase Symbol References - Locates and lists all occurrences of a specific code element across the entire project workspace.
• Upgradeable Contract Deployment - Supports the deployment of proxy-based architectures to enable upgradeable smart contract logic.
• Extensible Plugin Architectures - Features a plugin-based architecture that allows the loading of custom local or remote tool extensions.
• URL-Based Plugin Loading - Fetches source code and files from external URLs or Gists to be used within the development workspace.
• URL Configuration Handlers - Bootstraps the IDE state, including plugins and compiler versions, using parameters encoded in the application URL.
• Project Configuration - Uses project configuration files to synchronize compiler settings and dependencies across different workspaces.
• Proxy Implementation Upgrading - Enables updating proxy or beacon contracts to point to new implementation logic for seamless upgrades.
• URL State Serialization - Automatically configures the IDE state and plugin set via parameters embedded in the application URL.
• Blockchain Monitoring Systems - Displays real-time logs of transactions and blockchain actions to track interaction and mining status.
• Deployed Contract Monitoring - Analyzes and tracks the real-time performance and behavior of smart contracts deployed on a blockchain.
• Stack Trace Hierarchy Visualizers - Provides interactive visualizations of nested call hierarchies within blockchain transactions to trace execution paths.
• Transaction Receipt Inspection - Displays transaction receipts and execution logs in a terminal to verify contract behavior.
• CLI Test Runners - Executes smart contract unit tests via a command-line interface for integration into CI pipelines.
• Code Autocomplete Engines - Offers context-aware code completions for contract members, workspace files, and library imports.

Star history