Every Plugin is an open-source framework for developers who want to build plugin systems that are composable and type-safe. It is aimed at JavaScript and TypeScript teams working on Web3 products, where extensions need to load, change and unload without breaking the host application.
The project is free and released under the MIT license. Its latest code update landed on February 15, 2026, and the current version is v0.4.0. Because it is a developer framework rather than an end-user application, it suits people comfortable working in a code editor and a terminal. This page covers what it does, how to get it onto a Windows machine, and where it fits among related tools.
What Is a Plugin Runtime?
A plugin runtime is the part of an application that discovers, loads, starts and stops extensions. Without one, every feature has to be compiled into the main app, and adding a new capability means redeploying everything.
A good runtime also defines what a plugin is allowed to touch. It sets rules for shared state, for errors and for cleanup when a plugin is removed. Every Plugin is built around these ideas, combining lifecycle handling with remote loading so the host and its extensions can evolve on different schedules.
Who Every Plugin Is For
The framework fits teams that expect third parties or internal groups to extend a product. Consider a platform where several teams own separate dashboards. Each team can ship a plugin that the host loads, while the platform keeps a single contract they all follow.
Solo developers can also benefit if they plan to grow a project into modules. Setting plugin boundaries early can make later refactoring less painful, though it adds upfront design work that a small app may not need.
Common Challenges When Plugins Load Remotely
Remote loading introduces problems that simple imports avoid. Two plugins may depend on different versions of the same library, and the host has to decide which one wins. Network failures can also leave a plugin unavailable at startup.
Typical mitigations include pinning shared dependencies, defining fallback behavior when a remote fails, and writing contract tests that run whenever the host or a plugin changes. These practices apply to most plugin systems, not only this one.
Key features
Composable plugin architecture
Lifecycle management with Effect
Remote loading and typed contracts
How to install Every Plugin on Windows
- 1
Get the source or release
Open the project's GitHub repository at github.com/near-everything/every-plugin and check the Releases page for v0.4.0. Confirm whether a Windows artifact is attached before downloading, since Windows support is listed as likely rather than guaranteed.
- 2
Verify the download
Download only from the GitHub repository or its Releases page. If a SHA-256 checksum or signature is published, compare it with your file using a tool such as PowerShell's Get-FileHash before extracting or running anything.
-
Install or build
Extract the files to a folder you control and follow the README for setup. Because this is a framework, many developers add it as a dependency inside a project rather than running an installer. If you build from source, use the toolchain the README names.
How to use Every Plugin
Every Plugin is used inside a project rather than launched on its own. A typical first session looks like this:
- Define the host application and the contract that plugins must follow.
- Write a plugin against that contract, keeping its resources inside the lifecycle handling.
- Expose the plugin as a remote module so the host can load it at runtime.
- Run the host locally and load the plugin, checking that types match before you move on.
- Repeat for each new plugin, updating the contract whenever the interface changes.
Keep the first project small. A single host, one contract and one plugin are enough to see how lifecycle handling and remote loading behave before you add more moving parts.
Pros & cons
- Free and MIT-licensed, so it can be used and modified freely
- Open source, with the code available on GitHub
- Combines lifecycle management, remote loading and typed contracts in one framework
- Recent code update in February 2026
- Version 0.4.0 suggests an early stage, so interfaces may change between releases
- Aimed at developers, with no graphical interface for end users
- Windows support depends on the release artifacts, so confirm before you start
Is Every Plugin safe?
Every Plugin is open-source code under the MIT license, which means you can read it before running it. Download it only from the GitHub repository or its Releases page, never from mirrors or links shared in chat. If a release includes a SHA-256 checksum or signature, verify it before you extract or run anything. Because the framework runs code inside your own applications, review its dependencies and any plugin you load from a remote source. The project is at version 0.4.0, so check the GitHub repository for the latest version before starting a new project.
- Official source only. Download from github.com/near-everything/every-plugin. Ignore ads and lookalike domains.
- Check the SHA-256. Compare the installer hash with the value the developer publishes before running it.
- Never share your seed phrase. No developer, support agent or website — including CryptApps — will ever ask for it.
Alternatives
Most tools in the similar-programs list target smart contract work. Foundry and Solidity handle compiling and testing contracts, Anchor builds Solana programs, and Visual Studio Code with Solidity extensions covers editing. Every Plugin sits at a different layer. It is a runtime framework for building plugin architectures inside an application, not a chain development kit. Developers who need to write and test contracts should look at those tools instead. Teams building an extensible front end or service may find Every Plugin a closer fit.
Specifications
- Price
- Free
- Type
- Open source
- License
- MIT
- Latest version
- v0.4.0
- Last update
- 15 Feb 2026
- Windows support
- Likely (builds for Windows; check releases)
- Source code
- github.com/near-everything/every-plugin
Frequently asked questions
Yes, Every Plugin is free and released under the MIT license. You can use, modify and distribute it under the terms of that license. The framework itself has no price, but any services or tools you build with it may carry their own costs. Read the license file in the repository for the full terms before using it commercially.
It is open-source code under the MIT license, so you can inspect it on GitHub before using it. Download only from the repository or its Releases page, verify any published checksum or signature, and review the code and dependencies before relying on them in production. Treat it like any developer library, since safety depends on the source you use and the review you perform.
No, it is a framework for developers rather than a desktop application with menus. You work with it through code in a TypeScript or JavaScript project. People without programming experience will find it hard to use directly, though a developer can build interfaces on top of it for end users.
Module Federation is a technique for loading code from another build at runtime, so a host application can use plugins that were built separately. In Every Plugin, it handles remote plugin loading. This lets teams ship plugin updates without rebuilding the whole host app, although keeping shared library versions aligned still requires care.
oRPC provides type-safe contracts between a host and its plugins. A contract describes the inputs and outputs of each call, so mismatches can appear as type errors while you code. That reduces guesswork when plugins are written by different people. It does not replace runtime testing, so keep tests for critical paths.
Start by reading the README in the GitHub repository and running any example it includes. Define a simple host and contract, write one plugin, and load it locally. Keep the first project small so you can see how lifecycle handling and remote loading behave before adding more plugins.
Verdict
Every Plugin suits JavaScript and TypeScript developers who need an extensible architecture with clear resource handling and typed contracts. It is free, MIT-licensed and recently updated. At version 0.4.0, however, it is early-stage, so expect API changes and plan for them. If you want a finished end-user program for Windows, this is not it. Start with a small test project before committing to it in a larger product.