union
The trust-minimized, zero-knowledge bridging protocol, designed for censorship resistance, extremely high security, and usage in decentralized finance.
- 74k
- Rust
- Apache-2.0
- 4 mo ago
UI Builder is an open-source blockchain development tool that helps developers and non-developers create user-friendly interfaces for smart contract interaction by providing a chain-agnostic form builder that generates standalone "mini apps" without requiring backend infrastructure.
Repo OpenZeppelin/ui-builder, read from GitHub 1 min ago. OpenZeppelin has not joined Take My Repo.
OpenZeppelin/ui-builder is a public repo on GitHub by OpenZeppelin. UI Builder is an open-source blockchain development tool that helps developers and non-developers create user-friendly interfaces for smart contract interaction by providing a chain-agnostic form builder that generates standalone "mini apps" without requiring backend infrastructure. It declares the AGPL-3.0 license on GitHub. It is written mainly in TypeScript, has 51 stars and last changed on 2026-11-21. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
Spin up a front-end for any contract call in seconds. Select the function, auto-generate a React UI with wallet connect and multi-network support, and export a complete app.
This project is currently in development.
CI Coverage Dependencies OpenSSF Scorecard License: AGPL v3
Conventional Commits Commitizen friendly TypeScript React Tailwind CSS Vite pnpm PRs Welcome
This repository contains the Builder application plus repository-level tooling, workflows, and export scripts.
Core UI packages are maintained in the openzeppelin-ui monorepo:
The main application with the builder UI, export system, and core logic.
For more details, see the Builder README.
Adapter implementations live in the
openzeppelin-adapters repository and are
published under the @openzeppelin/adapter-* namespace. Shared Vite/Vitest
integration for consuming apps is provided by @openzeppelin/adapters-vite.
@openzeppelin/adapter-evm@openzeppelin/adapter-midnight@openzeppelin/adapter-polkadot@openzeppelin/adapter-solana@openzeppelin/adapter-stellar@openzeppelin/adapters-vite (shared build-time integration helper)@openzeppelin/adapter-evm-core is an internal package bundled by the public EVM-oriented
adapters rather than consumed directly by Builder applications..github/workflows)Clone the repository:
git clone https://github.com/OpenZeppelin/ui-builder.git
cd ui-builderInstall dependencies:
pnpm install
Build all packages:
pnpm build
Start the development server:
pnpm dev
Open your browser and navigate to http://localhost:5173
For a consistent and reliable development environment, it is highly recommended to run the application using Docker. This avoids potential issues with local Node.js, pnpm, or operating system configurations.
Prerequisites: Make sure you have Docker and Docker Compose installed on your system.
Build and Run the Container:
docker-compose up --build
This command will build the Docker image and start the application. Once it's running, you can access it at http://localhost:3000.
pnpm dev - Start the development serverpnpm build - Build for productionpnpm lint - Run ESLintpnpm lint:fix - Fix ESLint issuespnpm lint:all-fix - Fix ESLint issues across all file typespnpm lint:config-files - Lint Vite/Vitest config files (read-only; fails on issues)pnpm lint:config-files:fix - Auto-fix lint issues in configuration files (builder app only; run via pnpm --filter=@openzeppelin/ui-builder-app lint:config-files:fix)pnpm format - Format code with Prettierpnpm format:check - Check formatting without making changespnpm fix-all - Run Prettier first, then ESLint to avoid conflicts with CSS class sortingpnpm preview - Preview the production buildpnpm ui:add - Add shadcn/ui componentspnpm test - Run testspnpm test:watch - Run tests in watch modepnpm test:coverage - Run tests with coverage reportpnpm commit - Run commitizen for guided commitspnpm update-deps - Update all monorepo dependencies to their latest versionspnpm update-deps:major - Update dependencies including major versionspnpm check-deps - Check for deprecated dependenciespnpm outdated - List outdated dependencies across the monorepopnpm export-app [cmd] [opts] - Export a standalone form project (see pnpm export-app --help)pnpm update-export-versions - Update the hardcoded versions of internal packages used in exported formsThis repository contains the Builder application and repository-level tooling.
@openzeppelin/adapter-*ui-builder/
├── .github/ # GitHub workflows and templates
├── .husky/ # Git hooks
├── test/ # Shared test setup and utilities
├── packages/ # Monorepo packages (see individual READMEs for detailed structure)
├── scripts/ # Utility scripts
├── tailwind.config.cjs # Central Tailwind CSS configuration
├── postcss.config.cjs # Central PostCSS configuration
├── components.json # Central shadcn/ui configuration
├── tsconfig.base.json # Base TypeScript configuration for all packages
├── pnpm-workspace.yaml # PNPM workspace configuration
└── ... # Other configuration files
For detailed application structure, see the Builder README linked above.
The application uses a modular, domain-driven adapter pattern to support multiple blockchain ecosystems. For the adapter source-of-truth, please see the Adapter Architecture Guide in the openzeppelin-adapters repository.
Key Components:
ecosystemManager.ts for discovering network configurations and adapter capabilities.@openzeppelin/ui-storage): IndexedDB-based persistence layer built on
Dexie.js providing:
@openzeppelin/adapter-*): Individual packages maintained in
openzeppelin-adapters containing chain-specific implementations (for example adapter-evm and
adapter-stellar). Each adapter exposes profile-based runtimes and capability factories.
Runtimes are instantiated with a specific NetworkConfig, making them network-aware. The Builder
app (via RuntimeProvider from @openzeppelin/ui-react) dynamically loads and manages these
runtimes. Furthermore, adapters can optionally provide UI-specific functionalities:
wagmi/react on EVM): WalletStateProvider (from @openzeppelin/ui-react) consumes this to set up the necessary app-wide context for the active runtime's ecosystem.useAccount, useSwitchChain): These are exposed by WalletStateProvider (via useWalletState().walletFacadeHooks from @openzeppelin/ui-react) for UI components to interact with wallet functionalities reactively and agnostically.ConnectButton): These components are retrieved via activeRuntime.uiKit.getEcosystemWalletComponents() and are expected to internally use the facade hooks.@openzeppelin/ui-renderer): Shared library containing app rendering components
and common utilities (like logging).@openzeppelin/ui-react): Centralized React state management providing:
useWalletState() and useRuntimeContext() for consistent state access@openzeppelin/ui-components): Comprehensive component library including:
This architecture allows for easy extension to support additional blockchain ecosystems without modifying the builder application logic. The builder package dynamically loads and uses adapters via ecosystemManager.ts and the provider model (from @openzeppelin/ui-react) and the export system includes the specific adapter package needed for the target chain in exported forms. It utilizes custom Vite plugins to create virtual modules, enabling reliable loading of shared assets (like configuration files between packages) across package boundaries, ensuring consistency between development, testing, and exported builds.
This project is governed by the UI Builder Constitution. Please read it before contributing changes that affect architecture, adapters, or tooling:
The primary build target in this repository is the Builder app, while adapter package builds and
adapter-specific validation live in openzeppelin-adapters.
For more detailed documentation about the capability-based adapter pattern, implementation guidelines, and validation rules, see docs/ADAPTER_ARCHITECTURE.md and the adapter/runtime types under packages/types/src/adapters/.
The project follows a structured component architecture centered around app rendering:
The @openzeppelin/ui-renderer package (maintained in the external openzeppelin-ui repo) provides:
The actual UI primitives (like TextField, AddressField, Button, Input) are sourced from the @openzeppelin/ui-components package and work exclusively with React Hook Form.
This project uses Husky to enforce code quality using Git hooks:
These hooks ensure that code pushed to the repository maintains consistent quality and style.
For consistent CSS class name sorting in Tailwind CSS, always run Prettier first, then ESLint:
# Recommended approach (runs formatting, then linting)
pnpm fix-allThis approach ensures that Tailwind CSS classes are consistently sorted by the prettier-plugin-tailwindcss plugin and prevents conflicts between formatting and linting tools.
This project uses a single, shared Prettier configuration at the root of the monorepo. Individual packages should not include their own .prettierrc files. The root configuration includes:
cva, cn, clsx, and twMergeTo format all packages:
pnpm format
Imports are automatically sorted in the following order:
@/)..).)This ordering is enforced by ESLint and automatically fixed on commit.
This project uses several tools to manage dependencies effectively:
The versions of internal @openzeppelin/ packages used in exported forms are centrally managed in the apps/builder/src/export/versions.ts file. This ensures that all exported projects use stable, tested, and reproducible dependency versions.
To update these versions to the latest published releases, run the following command from the root of the monorepo:
pnpm update-export-versions
This script will fetch the latest versions from the npm registry and update the versions.ts file automatically.
To see which dependencies are outdated:
pnpm outdated
For regular updates (respecting semver):
pnpm update-deps
For major version updates (may include breaking changes):
pnpm update-deps:major
The project is configured with:
New adapter packages should be created in openzeppelin-adapters, not in this repository.
To add support for a new ecosystem end-to-end:
openzeppelin-adapters under @openzeppelin/adapter-*.apps/builder/src/core/ecosystemManager.ts.This project follows Conventional Commits. See COMMIT_CONVENTION.md for more details.
Example:
feat(ui): add button component
Please read CONTRIBUTING.md for details on our code of conduct and the process for submitting pull requests.
Please read SECURITY.md for details on our security policy and how to report vulnerabilities.
This project is licensed under the GNU Affero General Public License v3.0 - see the LICENSE file for details.
This project uses GitHub Actions for continuous integration and delivery:
.github/workflows/docker-stg.yaml and docker-prod.yamlShared libraries (@openzeppelin/ui-*, @openzeppelin/adapter-*, etc.) are published from their own repositories; this repo ships the Builder web app only.
This project uses a centralized configuration approach to maintain consistency across all packages:
Packages consume these root configs via:
packages/*/tailwind.config.cjs and packages/*/postcss.config.cjs) that require the root configscomponents.json files (regular JSON) that reference the package CSS entry (e.g., ../styles/global.css)During the export process, proxy configs and JSON are included to create standalone configuration files for the exported project.
Both the main UI Builder application and its exported forms support runtime configuration for certain parameters. This is primarily managed via an AppConfigService and allows customization without rebuilding the application code.
During development of the builder application, configurations are typically provided via Vite environment variables defined in .env files (e.g., .env.local). These variables usually follow a prefix like VITE_APP_CFG_....
Key configurable items include:
VITE_APP_CFG_API_KEY_<IDENTIFIER>="your_key" (e.g., VITE_APP_CFG_API_KEY_ETHERSCAN_MAINNET)VITE_APP_CFG_SERVICE_<SERVICE>_API_KEY="your_key" (e.g., VITE_APP_CFG_SERVICE_ETHERSCANV2_API_KEY for unified Etherscan V2, or VITE_APP_CFG_SERVICE_ROUTESCAN_API_KEY for Routescan)VITE_APP_CFG_SERVICE_WALLETCONNECT_PROJECT_ID="your_id".VITE_APP_CFG_RPC_ENDPOINT_ETHEREUM_MAINNET="https://your_custom_rpc.com".VITE_APP_CFG_INDEXER_ENDPOINT_STELLAR_TESTNET="https://your_indexer.com/graphql".Exported forms include a public/app.config.json file. Users of the exported form should edit this file to provide their own API keys and RPC URLs.
The structure of this JSON file includes sections for:
networkServiceConfigs: For per-network explorer API keys, keyed by a service identifier (e.g., "etherscan-mainnet").globalServiceConfigs: For global service parameters (e.g., walletconnect.projectId) and unified explorer API keys (e.g., etherscanv2.apiKey for Etherscan V2, routescan.apiKey for Routescan).rpcEndpoints: For RPC URL overrides, keyed by the network ID (e.g., "ethereum-mainnet").indexerEndpoints: For indexer endpoint overrides, keyed by the network ID (e.g., "stellar-testnet"). Values can be strings (HTTP URL) or objects with http and ws properties.Refer to the README included with the exported application for detailed instructions on configuring public/app.config.json.
OpenZeppelin/ui-builder is a public repo on GitHub by OpenZeppelin. UI Builder is an open-source blockchain development tool that helps developers and non-developers create user-friendly interfaces for smart contract interaction by providing a chain-agnostic form builder that generates standalone "mini apps" without requiring backend infrastructure.
It declares the AGPL-3.0 license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-21. Take My Repo does not judge from that whether it is maintained.
The trust-minimized, zero-knowledge bridging protocol, designed for censorship resistance, extremely high security, and usage in decentralized finance.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
📋 React Hooks for form state management and validation (Web + React Native)
Write components once, run everywhere. Compiles to React, Vue, Qwik, Solid, Angular, Svelte, and more.

OpenZeppelin Contracts is a library for secure smart contract development.
Upgradeable variant of OpenZeppelin Contracts, meant for use in upgradeable contracts.
OpenZeppelin Contracts written in Cairo for Starknet, a decentralized ZK Rollup
Plugins for Hardhat and Foundry to deploy and manage upgradeable contracts on Ethereum.
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/OpenZeppelin/ui-builderTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.