awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
steipete avatar

steipete/AspectsArchived

0
View on GitHub↗
twitter.com/steipete↗

Aspects

Aspects is an aspect-oriented programming library and method hooking framework designed for intercepting and modifying JavaScript function behavior without altering the original source code. It serves as a runtime logic injector that allows for the addition and removal of executable code wrappers from active functions.

The library enables the injection of custom logic before or after methods to change application behavior at runtime. It further provides the ability to intercept method calls to capture or override return values before they reach the caller.

The framework manages these interceptions through a dynamic proxy wrapper and uses token-based tracking to deregister specific logic layers and restore original method behavior.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Features

  • Aspect-Oriented Programming Frameworks - Provides a framework for implementing cross-cutting concerns by injecting custom logic into functions.
  • Method Hooking Frameworks - Provides a framework for intercepting and modifying JavaScript function behavior using runtime hooks.
  • Runtime Logic Modification - Changes how a software system operates by wrapping existing methods with new logic via dynamic hooks.
  • Runtime Logic Injectors - Implements a system for adding and removing executable code wrappers from active functions using token-based tracking.
  • Behavioral Logic Injection - Runs additional code before or after a method to change behavior without editing the original source.
  • Dynamic Function Interception - Captures function calls to execute additional code or modify return values before they reach the original caller.
  • Higher-Order Function Wrapping - Wraps original functions in a proxy layer to execute custom logic before and after the core method runs.
  • Runtime Logic Injection - Injects custom executable code into existing method paths during application execution to extend functionality.
  • Method Interception Proxies - Adds or changes behavior in existing functions at runtime without altering the original source code.
  • Method Logic Injection - Runs additional code before or after a method to change behavior without editing the original source.
  • Runtime Method Patching - Swaps original function references with decorated versions at runtime to modify behavior without altering source code.
  • Hook Lifecycle Tracking - Stores unique identifiers for each injected wrapper to allow precise removal of specific logic layers from the call stack.
  • Method Return Values - Intercepts function calls to modify or replace the returned values before they reach the caller.
  • Return Value Interceptors - Intercepts method calls to capture or override the value sent back to the caller.
  • Return Value Transformers - Captures the output of wrapped functions and applies transformations before passing the result back to the caller.
  • Method Hooking - Deregisters logic wrappers using unique tokens to restore the original behavior of a method.
8,436 stars·1,268 forks·Objective-C·mit·14 views

Star history

Star history chart for steipete/aspectsStar history chart for steipete/aspects

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Frequently asked questions

What does steipete/aspects do?

Aspects is an aspect-oriented programming library and method hooking framework designed for intercepting and modifying JavaScript function behavior without altering the original source code. It serves as a runtime logic injector that allows for the addition and removal of executable code wrappers from active functions.

What are the main features of steipete/aspects?

The main features of steipete/aspects are: Aspect-Oriented Programming Frameworks, Method Hooking Frameworks, Runtime Logic Modification, Runtime Logic Injectors, Behavioral Logic Injection, Dynamic Function Interception, Higher-Order Function Wrapping, Runtime Logic Injection.

Which projects share features with steipete/aspects?

Projects with overlapping indexed features include: aslody/virtualapp — VirtualApp is an Android application virtualization engine and user-space sandbox that enables the execution of… code4craft/tiny-spring — tiny-spring is a Java inversion of control container and aspect-oriented programming framework. It provides a system… derekyrc/mini-spring — mini-spring is a Java dependency injection framework and inversion of control container. It manages the full lifecycle… alibaba/jvm-sandbox — jvm-sandbox is a bytecode instrumentation framework and plugin container for the Java Virtual Machine. It acts as a… bang590/jspatch — JSPatch is a JavaScript native bridge and method swizzler that allows for the dynamic injection of logic into a hosted… fuzhengwei/small-spring — Small-Spring is a simplified Java implementation of the Spring framework designed to study the internal architecture…

Projects sharing features with Aspects

These projects share indexed features with Aspects. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • aslody/virtualappasLody avatar

    asLody/VirtualApp

    11,010View on GitHub↗

    VirtualApp is an Android application virtualization engine and user-space sandbox that enables the execution of applications within an isolated environment. It allows for the running of multiple independent instances of the same application on a single device and supports private application installation without requiring system-level root access. The project features a comprehensive hooking framework for intercepting Java and native layer functions to modify application behavior. It includes tools for hardware simulation to spoof device models and system information, as well as a non-root pr

    Javaandroidframeworkplugin
    View on GitHub↗11,010
  • bang590/jspatchbang590 avatar

    bang590/JSPatch

    11,330View on GitHub↗

    JSPatch is a JavaScript native bridge and method swizzler that allows for the dynamic injection of logic into a hosted native environment. It functions as a cross-language data mapper and execution engine, enabling the replacement of native function pointers with JavaScript wrappers to modify application behavior at runtime. The project provides the ability to perform runtime application patching by overriding native class methods and object properties. This allows for the modification of application logic and the application of hotfixes using JavaScript code loaded from local files or remote

    Objective-C
    View on GitHub↗11,330
  • alibaba/jvm-sandboxalibaba avatar

    alibaba/jvm-sandbox

    6,951View on GitHub↗

    jvm-sandbox is a bytecode instrumentation framework and plugin container for the Java Virtual Machine. It acts as a runtime application modifier that enables the injection and modification of bytecode in a running process without requiring an application restart or changes to the original source code. The system provides a non-invasive aspect-oriented programming framework to intercept method execution and alter behavior in live processes. It functions as an isolated environment for functional modules, employing a custom class loader hierarchy to prevent dependency conflicts between plugins a

    Java
    View on GitHub↗6,951
  • code4craft/tiny-springcode4craft avatar

    code4craft/tiny-spring

    4,089View on GitHub↗

    tiny-spring is a Java inversion of control container and aspect-oriented programming framework. It provides a system for managing object lifecycles and dependency injection to decouple application components. The project features a bytecode proxy generator that enables method interception and behavioral modification for classes that do not implement interfaces. It uses pointcut expressions to match specific classes and methods for the execution of cross-cutting logic via dynamic proxies. The framework manages singleton components and resolves object dependencies using lazy initialization. Ap

    Java
    View on GitHub↗4,089
Compare all 30 related projects→