PHPackages vinexel/vinexel - PHPackages - PHPackages [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register) 1. [Directory](/) 2. / 3. [Framework](/categories/framework) 4. / 5. vinexel/vinexel ActiveProject[Framework](/categories/framework) vinexel/vinexel =============== A fullstack multi project web framework with Hierarchical Model View Controller (H-MVC) Multi Project, hybrid Golang restapi and PHP Rapid Framework v1.0.0(10mo ago)46MITCSSPHP ^8.3 Since Oct 20Pushed 2w agoCompare [ Source](https://github.com/vinexel/vinexel-framework)[ Packagist](https://packagist.org/packages/vinexel/vinexel)[ Docs](https://vinexel.com)[ RSS](/packages/vinexel-vinexel/feed)WikiDiscussions main Synced 1w ago READMEChangelog (1)Dependencies (1)Versions (3)Used By (0) [![Vinexel Framework Logo](https://camo.githubusercontent.com/3973138f35752a20e7f77f2a62beadafe2978c68f3a112eef4740f3ae66b3f66/68747470733a2f2f76696e6578656c2e636f6d2f7374617469632f76696e6578656c2f696d616765732f6c6f676f2e706e67)](https://camo.githubusercontent.com/3973138f35752a20e7f77f2a62beadafe2978c68f3a112eef4740f3ae66b3f66/68747470733a2f2f76696e6578656c2e636f6d2f7374617469632f76696e6578656c2f696d616765732f6c6f676f2e706e67)VINEXEL Framework ================= [](#vinexel-framework) ### Vivid Innovation for Excellence [](#vivid-innovation-for-excellence) **A science-driven PHP framework for modular, multi-project, and interconnected application ecosystems.** > **“Think differently. Build the Vinexel way.”**— *Vinexel Pioneers* [![PHP](https://camo.githubusercontent.com/38027453aeb7eb818641c9de8f82b7624c3558d92634f1946edc715c3ddf8956/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f5048502d382e332532422d3737374242343f6c6f676f3d706870266c6f676f436f6c6f723d7768697465)](https://camo.githubusercontent.com/38027453aeb7eb818641c9de8f82b7624c3558d92634f1946edc715c3ddf8956/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f5048502d382e332532422d3737374242343f6c6f676f3d706870266c6f676f436f6c6f723d7768697465)[![Architecture](https://camo.githubusercontent.com/20f6adb2a22a42fe704a32af63f35decfebe476f419e232437a9df1a1e34dfa4/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4172636869746563747572652d4879627269642532304d6f64756c6172253230484d56432d304137454134)](https://camo.githubusercontent.com/20f6adb2a22a42fe704a32af63f35decfebe476f419e232437a9df1a1e34dfa4/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4172636869746563747572652d4879627269642532304d6f64756c6172253230484d56432d304137454134)[![Projects](https://camo.githubusercontent.com/6e94d3d8e9da41041018c3c4f7022f93dfcb71442597a21758bfdc77118a20ca/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f50726f6a656374732d4d756c74692d2d50726f6a6563742d313841353538)](https://camo.githubusercontent.com/6e94d3d8e9da41041018c3c4f7022f93dfcb71442597a21758bfdc77118a20ca/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f50726f6a656374732d4d756c74692d2d50726f6a6563742d313841353538)[![License](https://camo.githubusercontent.com/5caa455d8debc46fb23abbadb45a733a937f3910a73fc875c2f7820468e1bb54/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4c6963656e73652d4d49542d677265656e)](https://camo.githubusercontent.com/5caa455d8debc46fb23abbadb45a733a937f3910a73fc875c2f7820468e1bb54/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4c6963656e73652d4d49542d677265656e) --- About Vinexel Framework ----------------------- [](#about-vinexel-framework) **Vinexel Framework** is a next-generation PHP framework engineered for high-performance, modular, multi-domain, and multi-project application architectures. It combines: - the clarity of modern PHP; - the modularity of hierarchical MVC; - the flexibility of domain-oriented architecture; - the structural discipline of Clean Architecture; - and the operational efficiency of a shared application core. Vinexel is designed to support multiple independent projects, domains, platforms, or tenants from a single interconnected framework foundation. Rather than treating every application as an isolated codebase, Vinexel enables related systems to share common infrastructure while preserving clear project boundaries. It can be used as the foundation for: - e-commerce platforms; - software-as-a-service applications; - single sign-on services; - multi-domain platforms; - internal business systems; - modular web applications; - and enterprise-grade ecosystems. Vinexel is not merely a collection of framework components. It is an engineering foundation for building connected technological systems. Engineering Philosophy ---------------------- [](#engineering-philosophy) Vinexel is developed through scientific reasoning, first-principles thinking, measurable engineering decisions, and continuous refinement. Its architecture is guided by the principle that software should remain understandable as it grows. PrincipleApplication**Simplicity**Remove unnecessary complexity without weakening functionality.**Clarity**Maintain explicit responsibilities, predictable structures, and readable execution flows.**Modularity**Separate systems into focused components with controlled dependencies.**Efficiency**Minimize unnecessary computation, memory usage, network activity, and development overhead.**Consistency**Apply predictable conventions across projects, domains, modules, and environments.**Scalability**Enable systems to expand without requiring a complete architectural rewrite.**Interconnection**Allow projects to share infrastructure and capabilities without losing isolation.**Reproducibility**Make installation, configuration, testing, and deployment processes repeatable.**Observability**Make system behavior easier to inspect, measure, debug, and improve.**Continuous Refinement**Treat every implementation as a foundation that can be tested and improved. Scientific Development Method ----------------------------- [](#scientific-development-method) Vinexel applies an iterative engineering method to framework development: ``` Observe a real problem ↓ Identify its fundamental causes ↓ Form an architectural hypothesis ↓ Design a focused implementation ↓ Measure correctness and efficiency ↓ Validate through practical usage ↓ Document the findings ↓ Refine and integrate ``` Architectural decisions should not be based solely on convention or popularity. Every significant implementation should be evaluated according to: - correctness; - maintainability; - performance; - resource consumption; - security; - developer experience; - operational impact; - and long-term scalability. A Pioneering Framework ---------------------- [](#a-pioneering-framework) Vinexel does not aim to reproduce existing PHP frameworks under a different name. Its purpose is to explore a distinct framework model for interconnected application ecosystems. Vinexel pioneers an approach in which: - multiple projects can operate from one framework installation; - domains can be resolved dynamically at runtime; - shared infrastructure remains independent from project-specific business logic; - applications can remain isolated while participating in the same ecosystem; - framework capabilities can evolve without forcing every project to duplicate them; - and architectural rules can remain consistent across an expanding platform. Innovation within Vinexel is not pursued for novelty alone. Every new concept must improve clarity, efficiency, accessibility, maintainability, or long-term technological value. --- Architectural Overview ---------------------- [](#architectural-overview) Vinexel adopts a **Hybrid Modular HMVC Multi-Project Architecture** enriched with principles from: - Clean Architecture; - Domain-Oriented Design; - layered application architecture; - modular monolith design; - dependency separation; - and shared-kernel systems. Its architecture separates the shared framework foundation from project-specific application logic. ``` ┌─────────────────────────────────────────────────────────────┐ │ Incoming HTTP Request │ └─────────────────────────────┬───────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ Domain and Project Resolution │ │ │ │ example-one.com → ProjectOne │ │ example-two.com → ProjectTwo │ │ example-three.com → ProjectThree │ └─────────────────────────────┬───────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ Project Application Layer │ │ │ │ Controllers · Services · Models · Routes · Views │ └─────────────────────────────┬───────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ Shared Vinexel Foundation │ │ │ │ Router · Middleware · Database · Cache · Session · Security │ │ CLI · Templates · Configuration · Runtime Infrastructure │ └─────────────────────────────────────────────────────────────┘ ``` Each project remains structurally isolated while using the same framework core and infrastructure. This architecture is suitable for both: ### Multi-Project Systems [](#multi-project-systems) Several independent applications run from one Vinexel installation. ### Multi-Domain Systems [](#multi-domain-systems) Different domains or ports are connected to different projects at runtime. ### Multi-Tenant Systems [](#multi-tenant-systems) Several tenants share infrastructure while retaining separate identity, configuration, access, and application data. ### Interconnected Platforms [](#interconnected-platforms) Multiple applications communicate through shared authentication, services, infrastructure, or ecosystem standards. Architectural Objectives ------------------------ [](#architectural-objectives) Vinexel is designed to achieve the following objectives: 1. **Clear project isolation**Project-specific business logic should not leak into unrelated projects. 2. **Shared infrastructure**Routing, sessions, security, database access, caching, and other foundational capabilities can be reused. 3. **Controlled dependencies**Higher-level application modules should not depend unpredictably on unrelated implementation details. 4. **Replaceable components**Infrastructure components should be replaceable without rewriting the entire application. 5. **Predictable growth**Adding new projects should not require duplicating the complete framework foundation. 6. **Operational consistency**Development, testing, installation, and deployment should follow consistent conventions. --- Key Features ------------ [](#key-features) Modular Multi-Project Architecture ---------------------------------- [](#modular-multi-project-architecture) - Hybrid HMVC and multi-project application structure. - Independent controllers, models, services, routes, and views for each project. - Shared framework infrastructure across multiple applications. - Explicit project and domain boundaries. - Modular organization for long-term maintainability. - Support for an unlimited number of projects, subject to available infrastructure. Dynamic Domain Resolution ------------------------- [](#dynamic-domain-resolution) Vinexel can identify the active project from the incoming host or port. Example development mappings: ``` 127.0.0.1:8000 → ProjectOne 127.0.0.1:8001 → ProjectTwo 127.0.0.1:8002 → ProjectThree ``` Example production mappings: ``` platform-one.example → ProjectOne platform-two.example → ProjectTwo platform-three.example → ProjectThree ``` Domain resolution can be configured using project configuration, environment data, or a database-driven tenant resolver. Routing System -------------- [](#routing-system) - Project-specific route definitions. - Named routes. - Dynamic route parameters. - Route middleware. - Controller and method dispatching. - Domain-aware route loading. - Cached or dynamically generated route definitions. - Clear separation between routing and application execution. Example: ``` Router::get('/users/{id}', 'UserController@show') ->name('users.show') ->middleware('auth'); ``` Middleware Pipeline ------------------- [](#middleware-pipeline) Vinexel provides middleware support for request filtering and application access control. Typical middleware responsibilities include: - authentication; - authorization; - session initialization; - CSRF validation; - request sanitization; - guest restrictions; - administrative access; - rate limiting; - and project-specific policies. Example aliases: ``` 'auth' 'guest' 'admin' 'csrf' ``` Middleware can be applied globally or to individual routes. Security Foundation ------------------- [](#security-foundation) Vinexel provides a security-oriented request lifecycle with support for: - CSRF protection; - secure session handling; - input validation; - input sanitization; - prepared database statements; - password hashing; - authentication restrictions; - authorization middleware; - secure recovery workflows; - environment-based configuration; - and structured security exceptions. Security is treated as a system-wide architectural concern rather than an isolated utility. Authentication and Access Control --------------------------------- [](#authentication-and-access-control) Vinexel includes authentication capabilities for common application workflows. ### `Protection` [](#protection) Restricts protected application areas to authenticated users. ### `Restriction` [](#restriction) Prevents authenticated users from accessing pages intended only for guests, such as login or registration pages. Supported authentication capabilities can include: - session-based authentication; - password hashing; - account activation; - email verification; - activation codes; - PIN-based account recovery; - role-based authorization; - and multi-application authentication. Single Sign-On Support ---------------------- [](#single-sign-on-support) Vinexel can support Single Sign-On across interconnected applications. A shared authentication foundation can allow users to: - authenticate once; - access multiple authorized applications; - maintain consistent identity across domains; - and preserve project-specific authorization boundaries. SSO implementations should use secure cookie policies, controlled domain scope, token validation, session rotation, and explicit application trust relationships. Database Layer -------------- [](#database-layer) Vinexel provides a PDO-based database abstraction through: ``` Vision\Modules\Database ``` The database layer supports: - PDO connections; - prepared statements; - bound parameters; - transaction-safe operations; - structured query execution; - single-row retrieval; - multiple-row retrieval; - affected-row inspection; - and generated identifier retrieval. Common methods include: ``` query() bind() execute() single() resultSet() rowCount() lastInsertId() beginTransaction() commit() rollBack() ``` Example: ``` $this->database->query( 'SELECT id, name, email FROM users WHERE email = :email LIMIT 1' ); $this->database->bind(':email', $email); $user = $this->database->single(); ``` Prepared statements and bound parameters should be used consistently to reduce SQL injection risks. Redis Integration ----------------- [](#redis-integration) Vinexel includes an internal Redis integration layer: ``` Deeper\Libraries\Redis ``` Redis can be used for: - application caching; - session storage; - flash messages; - distributed state; - temporary data; - authentication coordination; - rate limiting; - and cross-application communication. Performance characteristics should be evaluated through reproducible benchmarks under representative workloads. Session and Flash Utilities --------------------------- [](#session-and-flash-utilities) Vinexel provides integrated session and notification utilities. ### Session [](#session) Supports: - session initialization; - session persistence; - user authentication state; - project-level session data; - and Redis-backed session storage. ### Flasher [](#flasher) Supports temporary notification messages such as: - success; - information; - warning; - validation error; - and system failure. Flash messages can be rendered using interface systems such as Bootstrap or Tailwind CSS. View and Templating System -------------------------- [](#view-and-templating-system) Vinexel provides a flexible view layer supporting native PHP and rapid template rendering. Supported template formats include: ``` .php .rapid.php ``` ### Native PHP Views [](#native-php-views) Use standard PHP syntax for complete flexibility and direct language access. ### Rapid Templates [](#rapid-templates) Use Vinexel's rapid templating conventions for concise and structured interface development. ### Twig-Based Capabilities [](#twig-based-capabilities) Vinexel can integrate Twig-style template capabilities for: - template inheritance; - reusable components; - layouts; - escaped output; - loops; - conditions; - filters; - and global helper functions. Example helpers may include: ``` asset() route() locale() getUserData() getUserEmail() ``` Installer and Environment Bootstrapping --------------------------------------- [](#installer-and-environment-bootstrapping) Vinexel includes installation and environment initialization capabilities. The installer can: - verify server requirements; - initialize application configuration; - configure database credentials; - create initial administrative credentials; - prepare environment files; - validate writable directories; - and mark the application as installed. Configuration can use: ``` .env config.php ``` A fallback configuration mechanism can be used when environment-file loading is unavailable. CLI and Developer Tools ----------------------- [](#cli-and-developer-tools) Vinexel includes the `vision` command-line interface for common framework operations. Examples: ``` php vision serve php vision make:controller UserController php vision make:model User php vision make:service UserService php vision make:middleware Authenticate php vision make:migration CreateUsersTable ``` The CLI is intended to reduce repetitive work while preserving explicit and readable generated code. Environment Management ---------------------- [](#environment-management) Vinexel supports environment-specific behavior. ``` development testing production ``` Environment configuration can control: - error reporting; - debugging; - logging; - cache behavior; - database connections; - external services; - session policies; - and security settings. Production environments should disable detailed public error output and use centralized logging. Performance-Oriented Design --------------------------- [](#performance-oriented-design) Vinexel is designed to minimize unnecessary framework overhead through: - lightweight application bootstrapping; - controlled service initialization; - route caching; - configuration caching; - optimized autoloading; - prepared database operations; - Redis-backed caching; - reusable framework infrastructure; - and project-specific loading. Performance claims should be validated using transparent benchmarks that measure: - requests per second; - response latency; - memory consumption; - CPU utilization; - database query count; - cache effectiveness; - and application startup time. Observability and Reliability ----------------------------- [](#observability-and-reliability) A production-ready Vinexel application should support: - structured application logs; - request identifiers; - error classification; - execution timing; - database query inspection; - cache monitoring; - security-event logging; - health checks; - and environment-aware diagnostics. Reliable systems must be measurable. Without observability, performance problems, security failures, and architectural regressions become difficult to identify objectively. --- Suggested Project Structure --------------------------- [](#suggested-project-structure) ``` vinexel/ ├── app/ │ ├── ProjectOne/ │ │ ├── Controllers/ │ │ ├── Models/ │ │ ├── Services/ │ │ ├── Middleware/ │ │ ├── Routes/ │ │ ├── Views/ │ │ └── Config/ │ │ │ ├── ProjectTwo/ │ │ ├── Controllers/ │ │ ├── Models/ │ │ ├── Services/ │ │ ├── Middleware/ │ │ ├── Routes/ │ │ ├── Views/ │ │ └── Config/ │ │ │ └── Shared/ │ ├── Contracts/ │ ├── Services/ │ └── Resources/ │ ├── public/ │ └── index.php │ ├── system/ │ ├── framework/ │ ├── vendor/ │ └── storage/ │ ├── tests/ ├── .env ├── composer.json └── vision ``` The exact structure may evolve as Vinexel continues to refine its modular architecture. --- Requirements ------------ [](#requirements) Before installing Vinexel, ensure that your environment provides: - PHP 8.3 or later; - Composer; - PDO; - required database drivers; - JSON extension; - Mbstring extension; - OpenSSL extension; - and a supported web server. Optional infrastructure may include: - Redis; - MySQL or MariaDB; - PostgreSQL; - Nginx; - Apache; - and a process supervisor. --- Installation ------------ [](#installation) ### Install Composer [](#install-composer) Download and install Composer from: ### Create a New Vinexel Project [](#create-a-new-vinexel-project) ``` composer create-project vinexel/vinexel my-project ``` Enter the project directory: ``` cd my-project ``` ### Configure the Environment [](#configure-the-environment) Create or update the environment configuration: ``` APP_ENV=development APP_DEBUG=true APP_URL=http://127.0.0.1:8000 DB_CONNECTION=mysql DB_HOST=127.0.0.1 DB_PORT=3306 DB_DATABASE=vinexel DB_USERNAME=root DB_PASSWORD= ``` Use secure credentials and disable debugging before deploying to production. ### Run the Development Server [](#run-the-development-server) Start the default project: ``` php vision serve ``` Start a project using a specific port: ``` php vision serve 8001 ``` Example: ``` http://127.0.0.1:8001 ``` Additional projects can use different ports: ``` php vision serve 8002 php vision serve 8003 ``` ### Complete Installation [](#complete-installation) After starting the application, open the installation panel in your browser and complete the initial configuration. The installer can prepare: - application configuration; - database connectivity; - administrative credentials; - environment values; - and initial system state. --- Development Workflow -------------------- [](#development-workflow) A typical Vinexel development workflow follows these stages: ``` Define the project boundary ↓ Design routes and use cases ↓ Create controllers and services ↓ Implement domain and data logic ↓ Build views or API responses ↓ Test functionality and security ↓ Measure application behavior ↓ Document and refine ``` Controllers should coordinate requests and responses. Business logic should be placed in focused services or domain components rather than accumulating inside controllers. Models and repositories should manage data access without becoming responsible for unrelated presentation or request concerns. Architectural Discipline ------------------------ [](#architectural-discipline) Recommended dependency direction: ``` Routes ↓ Controllers ↓ Application Services ↓ Domain Logic ↓ Repositories and Infrastructure ``` Avoid dependency flows such as: ``` Model → Controller Service → Controller View → Database Infrastructure → Application UI ``` Architectural boundaries should remain explicit, testable, and enforceable. --- Use Cases --------- [](#use-cases) Vinexel is designed for systems such as: ### Multi-Brand Platforms [](#multi-brand-platforms) Operate several related brands from one shared framework foundation. ### SaaS Applications [](#saas-applications) Serve multiple organizations or tenants while preserving data and access isolation. ### E-Commerce Ecosystems [](#e-commerce-ecosystems) Connect storefronts, account systems, payment services, administration, and supporting applications. ### Single Sign-On Networks [](#single-sign-on-networks) Provide shared identity across several authorized projects and domains. ### Enterprise Applications [](#enterprise-applications) Develop modular operational systems with centralized infrastructure and controlled project boundaries. ### Developer Platforms [](#developer-platforms) Build interconnected tools, APIs, dashboards, marketplaces, and development services. --- Project Status -------------- [](#project-status) Vinexel Framework is under active development. The architecture, APIs, internal components, and documentation may continue to evolve as the framework is tested, measured, and refined. Production adoption should include: - version pinning; - automated testing; - security review; - database backups; - deployment rollback procedures; - and environment-specific validation. Documentation ------------- [](#documentation) Official documentation is currently being developed. Planned documentation includes: - installation; - configuration; - application lifecycle; - routing; - controllers; - services; - middleware; - database access; - authentication; - sessions; - caching; - Redis; - templating; - CLI commands; - testing; - deployment; - multi-project architecture; - multi-domain routing; - and tenant isolation. Contributing ------------ [](#contributing) Vinexel welcomes contributions that improve: - correctness; - security; - performance; - maintainability; - documentation; - testing; - accessibility; - and developer experience. Contributions should follow the scientific and engineering principles of the project: 1. Clearly define the problem. 2. Explain the proposed solution. 3. Include tests where applicable. 4. Document architectural consequences. 5. Avoid unnecessary complexity. 6. Provide measurements for performance-related claims. 7. Preserve compatibility unless a breaking change is explicitly justified. Responsible Innovation ---------------------- [](#responsible-innovation) Vinexel encourages experimentation while maintaining engineering responsibility. New capabilities should be assessed according to: - practical usefulness; - security implications; - resource efficiency; - maintainability; - compatibility; - accessibility; - and long-term ecosystem impact. The objective is not to add the greatest number of features. The objective is to create the strongest coherent foundation. --- Official Links -------------- [](#official-links) ResourceLink**Website**[vinexel.com](https://vinexel.com)**Documentation**Coming soon**Framework Author**Elwira Perdana**Ecosystem**Vinexel**License**MIT License Support Vinexel --------------- [](#support-vinexel) Vinexel grows through independent research, responsible engineering, documentation, experimentation, open-source collaboration, and ecosystem sponsorship. Sponsorship helps support: - continued framework development; - architectural research; - documentation; - testing infrastructure; - security improvement; - developer tools; - and long-term ecosystem sustainability. ### [Support the Vinexel Ecosystem](https://vinexel.com/sponsor) [](#support-the-vinexel-ecosystem) **Support the research. Advance the framework. Strengthen the ecosystem.** --- License ------- [](#license) Vinexel Framework is open-source software licensed under the **MIT License**. See the [`LICENSE`](LICENSE) file for the complete license terms. ### VISION · SCIENCE · INNOVATION · EXCELLENCE [](#vision--science--innovation--excellence) **Think differently. Engineer scientifically. Build the Vinexel way.** © VINEXEL — **Vivid Innovation for Excellence** ### Health Score 38 — LowBetter than 83% of packages Maintenance78 Regular maintenance activity Popularity8 Limited adoption so far Community6 Small or concentrated contributor base Maturity52 Maturing project, gaining track record Bus Factor1 Top contributor holds 100% of commits — single point of failure How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window. **Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores. **Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement. **Maturity (30%)** — Project age, version count, PHP version support, and release stability. ### Release Activity Cadence Every ~283 days Total 2 Last Release 19d ago ### Community Maintainers ![](https://avatars.githubusercontent.com/u/238950092?v=4)[Vinexel](/maintainers/vinexel)[@vinexel](https://github.com/vinexel) --- Top Contributors [![elwiraperdana](https://avatars.githubusercontent.com/u/125210348?v=4)](https://github.com/elwiraperdana "elwiraperdana (90 commits)") --- Tags phpframeworkhmvcgolanghybrid Golang and PHP FrameworkVinexelPHP Vinexel FrameworkGolang Vinexel FrameworkVinexel IndonesiaPHP VinexelGolang Vinexel ### Embed Badge ![Health badge](/badges/vinexel-vinexel/health.svg) ``` [![Health](https://phpackages.com/badges/vinexel-vinexel/health.svg)](https://phpackages.com/packages/vinexel-vinexel) ``` ### Alternatives [dframe/dframe PHP Framework - Dframe 136.5k7](/packages/dframe-dframe) PHPackages © 2026 [Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)