{"id":13458769,"url":"https://github.com/raphw/byte-buddy","last_synced_at":"2026-01-16T19:16:56.564Z","repository":{"id":12106933,"uuid":"14696091","full_name":"raphw/byte-buddy","owner":"raphw","description":"Runtime code generation for the Java virtual machine.","archived":false,"fork":false,"pushed_at":"2025-05-01T20:21:32.000Z","size":1005975,"stargazers_count":6485,"open_issues_count":30,"forks_count":813,"subscribers_count":166,"default_branch":"master","last_synced_at":"2025-05-01T21:39:34.932Z","etag":null,"topics":["byte-code","dynamic-proxy","instrumentation","java","java-agent","java-library","java-virtual-machine"],"latest_commit_sha":null,"homepage":"https://bytebuddy.net","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/raphw.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":".github/CONTRIBUTING.md","funding":".github/FUNDING.yml","license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":"SECURITY.md","support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null},"funding":{"github":"raphw","tidelift":"maven/net.bytebuddy:byte-buddy"}},"created_at":"2013-11-25T19:38:03.000Z","updated_at":"2025-05-01T20:21:38.000Z","dependencies_parsed_at":"2023-10-03T00:11:29.863Z","dependency_job_id":"1f214d47-dd84-4806-b130-742d7f786497","html_url":"https://github.com/raphw/byte-buddy","commit_stats":{"total_commits":6922,"total_committers":104,"mean_commits":66.5576923076923,"dds":0.276798613117596,"last_synced_commit":"9ba938e3c98e99fe18f3d01be89903727401913e"},"previous_names":[],"tags_count":302,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/raphw%2Fbyte-buddy","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/raphw%2Fbyte-buddy/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/raphw%2Fbyte-buddy/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/raphw%2Fbyte-buddy/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/raphw","download_url":"https://codeload.github.com/raphw/byte-buddy/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":252526168,"owners_count":21762446,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["byte-code","dynamic-proxy","instrumentation","java","java-agent","java-library","java-virtual-machine"],"created_at":"2024-07-31T09:00:57.087Z","updated_at":"2026-01-16T19:16:56.553Z","avatar_url":"https://github.com/raphw.png","language":"Java","readme":"Byte Buddy\n==========\n\n\u003ca href=\"https://bytebuddy.net\"\u003e\n\u003cimg src=\"https://raw.githubusercontent.com/raphw/byte-buddy/gh-pages/images/logo-bg.png\" alt=\"Byte Buddy logo\" height=\"180px\" align=\"right\" /\u003e\n\u003c/a\u003e\n\nruntime code generation for the Java virtual machine\n\n[![Actions Status](https://github.com/raphw/byte-buddy/workflows/CI/badge.svg)](https://github.com/raphw/byte-buddy/actions)\n[![Security Score](https://snyk-widget.herokuapp.com/badge/mvn/net.bytebuddy/byte-buddy/badge.svg)](https://snyk.io/test/github/raphw/byte-buddy)\n[![Coverage Status](https://img.shields.io/coveralls/raphw/byte-buddy/master.svg)](https://coveralls.io/r/raphw/byte-buddy?branch=master)\n[![Maven Central](https://img.shields.io/maven-central/v/net.bytebuddy/byte-buddy)](https://central.sonatype.com/artifact/net.bytebuddy/byte-buddy)\n[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/6251/badge)](https://bestpractices.coreinfrastructure.org/projects/6251)\n\nByte Buddy is a code generation and manipulation library for creating and modifying Java classes during the runtime of a\nJava application and without the help of a compiler. Other than the code generation utilities\nthat [ship with the Java Class Library](https://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Proxy.html), Byte\nBuddy allows the creation of arbitrary classes and is not limited to implementing interfaces for the creation of runtime\nproxies. Furthermore, Byte Buddy offers a convenient API for changing classes either manually, using a Java agent or\nduring a build.\n\nJava version compatibility\n==========================\n\nThe following table lists the minimal versions of Byte Buddy that is required need to support a certain Java \nclass file version without experimental support. The oldest supported Java version is Java 5, whereas class files\nof any older version can be transformed. As of 1.17.0, support will extend to new Java versions unless previously\nunknown class file features are discovered. This is possible through Byte Buddy's support of the Class File API. \n\n| Byte Buddy version | Supported Java version |\n|--------------------|------------------------|\n| 1.17.0             | 25+                    |\n| 1.15.4             | 24                     |\n| 1.14.12            | 23                     |\n| 1.14.8             | 22                     |\n| 1.14.3             | 21                     |\n| 1.12.18            | 20                     |\n| 1.12.9             | 19                     |\n| 1.11.6             | 18                     |\n| 1.10.19            | 17                     |\n\nUsage\n=====\n\nIn order to use Byte Buddy, one does not require an understanding of Java byte code or\nthe [class file format](https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html). In contrast, Byte Buddy’s API\naims for code that is concise and easy to understand for everybody. Nevertheless, Byte Buddy remains fully customizable\ndown to the possibility of defining custom byte code. Furthermore, the API was designed to be as non-intrusive as\npossible and as a result, Byte Buddy does not leave any trace in the classes that were created by it. For this reason,\nthe generated classes can exist without requiring Byte Buddy on the class path. Because of this feature, Byte Buddy’s\nmascot was chosen to be a ghost.\n\nByte Buddy is written in Java 5 but supports the generation of classes for any Java version. Byte Buddy is a\nlight-weight library and only depends on the visitor API of the Java byte code parser library\n[ASM](https://asm.ow2.io/) which does itself\n[not require any further dependencies](https://repo1.maven.org/maven2/org/ow2/asm/asm/5.0.4/asm-5.0.4.pom).\n\nAt first sight, runtime code generation can appear to be some sort of black magic that should be avoided and only few\ndevelopers write applications that explicitly generate code during their runtime. However, this picture changes when\ncreating libraries that need to interact with arbitrary code and types that are unknown at compile time. In this\ncontext, a library implementer must often choose between either requiring a user to implement library-proprietary\ninterfaces or to generate code at runtime when the user’s types becomes first known to the library. Many known libraries\nsuch as for example *Spring* or *Hibernate* choose the latter approach which is popular among their users under the term\nof using [*Plain Old Java Objects*](https://en.wikipedia.org/wiki/Plain_Old_Java_Object). As a result, code generation\nhas become an ubiquitous concept in the Java space. Byte Buddy is an attempt to innovate the runtime creation of Java\ntypes in order to provide a better tool set to those relying on code generation.\n\n___\n\n\u003ca href=\"https://bytebuddy.net\"\u003e\n\u003cimg src=\"https://raw.githubusercontent.com/raphw/byte-buddy/gh-pages/images/dukeschoice.jpg\" alt=\"Duke's Choice award\" height=\"110px\" align=\"left\" /\u003e\n\u003c/a\u003e\n\nIn October 2015, Byte Buddy was distinguished with a\n[*Duke's Choice award*](https://www.oracle.com/corporate/pressrelease/dukes-award-102815.html)\nby Oracle. The award appreciates Byte Buddy for its \"*tremendous amount of innovation in Java Technology*\". We feel very\nhonored for having received this award and want to thank all users and everybody else who helped making Byte Buddy the\nsuccess it has become. We really appreciate it!\n\n___\n\nByte Buddy offers excellent performance at production quality. It is stable and in use by distinguished frameworks and\ntools such as [Mockito](https://site.mockito.org/), [Hibernate](https://hibernate.org/)\n, [Jackson](https://github.com/FasterXML/jackson), [Google's Bazel build system](https://bazel.build/)\nand [many others](https://github.com/raphw/byte-buddy/wiki/Projects-using-Byte-Buddy). Byte Buddy is also used by a\nlarge number of commercial products to great result. It is currently downloaded over 75 million times a year.\n\nHello World\n-----------\n\nSaying *Hello World* with Byte Buddy is as easy as it can get. Any creation of a Java class starts with an instance of\nthe `ByteBuddy` class which represents a configuration for creating new types:\n\n```java\nClass\u003c?\u003e dynamicType = new ByteBuddy()\n  .subclass(Object.class)\n  .method(ElementMatchers.named(\"toString\"))\n  .intercept(FixedValue.value(\"Hello World!\"))\n  .make()\n  .load(getClass().getClassLoader())\n  .getLoaded();\nassertThat(dynamicType.newInstance().toString(), is(\"Hello World!\"));\n```\n\nThe default `ByteBuddy` configuration which is used in the above example creates a Java class in the newest version of\nthe class file format that is understood by the processing Java virtual machine. As hopefully obvious from the example\ncode, the created type will extend the `Object` class and overrides its `toString` method which should return a fixed\nvalue of `Hello World!`. The method to be overridden is identified by a so-called `ElementMatcher`. In the above\nexample, a predefined element matcher `named(String)` is used which identifies methods by their exact names. Byte Buddy\ncomes with numerous predefined and well-tested matchers which are collected in the `ElementMatchers`\nclass and which can be easily composed. The creation of custom matchers is however as simple as implementing the\n([functional](https://docs.oracle.com/javase/8/docs/api/java/lang/FunctionalInterface.html)) `ElementMatcher` interface.\n\nFor implementing the `toString` method, the `FixedValue` class defines a constant return value for the overridden\nmethod. Defining a constant value is only one example of many method interceptors that ship with Byte Buddy. By\nimplementing the `Implementation` interface, a method could however even be defined by custom byte code.\n\nFinally, the described Java class is created and then loaded into the Java virtual machine. For this purpose, a target\nclass loader is required. Eventually, we can convince ourselves of the result by calling the `toString` method on an\ninstance of the created class and finding the return value to represent the constant value we expected.\n\nA more complex example\n----------------------\n\nOf course, a *Hello World example* is a too simple use case for evaluating the quality of a code generation library. In\nreality, a user of such a library wants to perform more complex manipulations, for example by introducing hooks into the\nexecution path of a Java program. Using Byte Buddy, doing so is however equally simple. The following example gives a\ntaste of how method calls can be intercepted.\n\nByte Buddy expresses dynamically defined method implementations by instances of the `Implementation` interface. In the\nprevious example, `FixedValue` that implements this interface was already demonstrated. By implementing this interface,\na user of Byte Buddy can go to the length of defining custom byte code for a method. Normally, it is however easier to\nuse Byte Buddy's predefined implementations such as `MethodDelegation` which allows for implementing any method in plain\nJava. Using this implementation is straight forward as it operates by delegating the control flow to any POJO. As an\nexample of such a POJO, Byte Buddy can for example redirect a call to the only method of the following class:\n\n```java\npublic class GreetingInterceptor {\n  public Object greet(Object argument) {\n    return \"Hello from \" + argument;\n  }\n}\n```\n\nNote that the above `GreetingInterceptor` does not depend on any Byte Buddy type. This is good news because none of the\nclasses that Byte Buddy generates require Byte Buddy on the class path! Given the above `GreetingInterceptor`, we can\nuse Byte Buddy to implement the Java 8 `java.util.function.Function` interface and its abstract `apply` method:\n\n```java\nClass\u003c? extends java.util.function.Function\u003e dynamicType = new ByteBuddy()\n  .subclass(java.util.function.Function.class)\n  .method(ElementMatchers.named(\"apply\"))\n  .intercept(MethodDelegation.to(new GreetingInterceptor()))\n  .make()\n  .load(getClass().getClassLoader())\n  .getLoaded();\nassertThat((String) dynamicType.newInstance().apply(\"Byte Buddy\"), is(\"Hello from Byte Buddy\"));\n```\n\nExecuting the above code, Byte Buddy implements Java's `Function` interface and implements the `apply` method as a\ndelegation to an instance of the `GreetingInterceptor` POJO that we defined before. Now, every time that the\n`Function::apply` method is called, the control flow is dispatched to `GreetingInterceptor::greet` and the latter\nmethod's return value is returned from the interface's method.\n\nInterceptors can be defined to take with more generic inputs and outputs by annotating the interceptor's parameters.\nWhen Byte Buddy discovers an annotation, the library injects the dependency that the interceptor parameter requires. An\nexample for a more general interceptor is the following class:\n\n```java\npublic class GeneralInterceptor {\n  @RuntimeType\n  public Object intercept(@AllArguments Object[] allArguments,\n                          @Origin Method method) {\n    // intercept any method of any signature\n  }\n}\n```\n\nWith the above interceptor, any intercepted method could be matched and processed. For example, when matching\n`Function::apply`, the method's arguments would be passed as the single element of an array. Also, a `Method`\nreference to `Fuction::apply` would be passed as the interceptor's second argument due to the `@Origin`\nannotation. By declaring the `@RuntimeType` annotation on the method, Byte Buddy finally casts the returned value to the\nreturn value of the intercepted method if this is necessary. In doing so, Byte Buddy also applies automatic boxing and\nunboxing.\n\nBesides the annotations that were already mentioned there exist plenty of other predefined annotations. For example,\nwhen using the `@SuperCall` annotation on a `Runnable` or `Callable` type, Byte Buddy injects proxy instances that allow\nfor an invocation of a non-abstract super method if such a method exists. And even if Byte Buddy does not cover a use\ncase, Byte Buddy offers an extension mechanism for defining custom annotations.\n\nYou might expect that using these annotations ties your code to Byte Buddy. However, Java ignores annotations in case\nthat they are not visible to a class loader. This way, generated code can still exist without Byte Buddy! You can find\nmore information on the `MethodDelegation` and on all of its predefined annotations in its *javadoc* and in Byte Buddy's\ntutorial.\n\nChanging existing classes\n----------------------\n\nByte Buddy is not limited to creating subclasses but is also capable of redefining existing code. To do so, Byte Buddy\noffers a convenient API for defining\nso-called [Java agents](https://docs.oracle.com/javase/8/docs/api/java/lang/instrument/package-summary.html). Java\nagents are plain old Java programs that can be used to alter the code of an existing Java application during its\nruntime. As an example, we can use Byte Buddy to change methods to print their execution time. For this, we first define\nan interceptor similar to the interceptors in the previous examples:\n\n```java\npublic class TimingInterceptor {\n  @RuntimeType\n  public static Object intercept(@Origin Method method, \n                                 @SuperCall Callable\u003c?\u003e callable) {\n    long start = System.currentTimeMillis();\n    try {\n      return callable.call();\n    } finally {\n      System.out.println(method + \" took \" + (System.currentTimeMillis() - start));\n    }\n  }\n}\n```\n\nUsing a Java agent, we can now apply this interceptor to all types that match an `ElementMatcher` for\na `TypeDescription`. For the example, we choose to add the above interceptor to all types with a name that ends\nin `Timed`. This is done for the sake of simplicity whereas an annotation would probably be a more appropriate\nalternative to mark such classes for a production agent. Using Byte Buddy's `AgentBuilder` API, creating a Java agent is\nas easy as defining the following agent class:\n\n```java\npublic class TimerAgent {\n  public static void premain(String arguments, \n                             Instrumentation instrumentation) {\n    new AgentBuilder.Default()\n      .type(ElementMatchers.nameEndsWith(\"Timed\"))\n      .transform((builder, type, classLoader, module, protectionDomain) -\u003e \n          builder.method(ElementMatchers.any())\n                 .intercept(MethodDelegation.to(TimingInterceptor.class))\n      ).installOn(instrumentation);\n  }\n}\n```\n\nSimilar to Java's `main` method, the `premain` method is the entry point to any Java agent from which we apply the\nredefinition. As one argument, a Java agent receives an instance of the `Instrumentation` interface which allows Byte\nBuddy to hook into the JVM's standard API for runtime class redefinition.\n\nThis program is packaged together with a manifest file with\nthe [`Premain-Class` attribute](https://docs.oracle.com/javase/8/docs/api/java/lang/instrument/package-summary.html)\npointing to the `TimerAgent`. The resulting *jar* file can now be added to any Java application by\nsetting `-javaagent:timingagent.jar` similar to adding a jar to the class path. With the agent active, all classes\nending in `Timed` do now print their execution time to the console.\n\nByte Buddy is also capable of applying so-called runtime attachments by disabling class file format changes and using\nthe `Advice` instrumentation. Please refer to the *javadoc* of the `Advice` and the `AgentBuilder` class for further\ninformation. Byte Buddy also offers the explicit change of Java classes via a `ByteBuddy` instance or by using the Byte\nBuddy *Maven* and *Gradle* plugins.\n\nWhere to go from here?\n----------------------\n\nByte Buddy is a comprehensive library and we only scratched the surface of Byte Buddy's capabilities. However, Byte\nBuddy aims for being easy to use by providing a domain-specific language for creating classes. Most runtime code\ngeneration can be done by writing readable code and without any knowledge of Java's class file format. If you want to\nlearn more about Byte Buddy, you can find such a [tutorial on Byte Buddy's web page](https://bytebuddy.net/#/tutorial) (\nThere is also [a Chinese translation available](https://notes.diguage.com/byte-buddy-tutorial/)).\n\nFurthermore, Byte Buddy comes with a [detailed in-code documentation](https://bytebuddy.net/#/javadoc) and extensive\ntest case coverage which can also serve as example code. Finally, you can find an up-to-date list of articles and\npresentations on Byte Buddy [in the wiki](https://github.com/raphw/byte-buddy/wiki/Web-Resources). When using Byte\nBuddy, make also sure to read the following information on maintaining a project dependency.\n\nGetting support\n----------------------------\n\n#### Commercial ####\n\nThe use of Byte Buddy is free and does not require the purchase of a license. To get the most out of the library or to\nsecure an easy start, it is however possible to purchase training, development hours or support plans. Rates are\ndependent on the scope and duration of an engagement. Please get in touch with \u003crafael.wth@gmail.com\u003e for further\ninformation.\n\n#### Tidelift ####\n\nByte Buddy\nis [listed on Tidelift](https://tidelift.com/subscription/pkg/maven-net-bytebuddy-byte-buddy?utm_source=byte-buddy\u0026utm_medium=referral)\n. If you are not using Byte Buddy to an extent where you want to purchase explicit support and want to support the open\nsource community in general, please consider a subscription.\n\n#### GitHub sponsors ####\n\nYou can support my work via [GitHub sponsors](https://github.com/sponsors/raphw). Note that this option is only meant\nfor commercial actors who are looking for a simple payment channel and that do not expect support in return. Support via\nGitHub Sponsors is not possible to maintain VAT compliance. Please reach out for a direct support agreement instead.\n\n#### Free ####\n\nGeneral questions can be asked on [Stack Overflow](https://stackoverflow.com/questions/tagged/byte-buddy) or on\nthe [Byte Buddy mailing list](https://groups.google.com/forum/#!forum/byte-buddy) which also serve as an archive for\nquestions. Of course, bug reports will be considered also outside of a commercial plan. For open source projects, it is\nsometimes possible to receive extended help for taking Byte Buddy into use.\n\nDependency and API evolution\n----------------------------\n\nByte Buddy is written on top of [ASM](https://asm.ow2.io), a mature and well-tested library for reading and writing\ncompiled Java classes. In order to allow for advanced type manipulations, Byte Buddy is intentionally exposing the ASM\nAPI to its users. Of course, the direct use of ASM remains fully optional and most users will most likely never require\nit. This choice was made such that a user of Byte Buddy is not restrained to its higher-level functionality but can\nimplement custom implementations without a fuss when it is necessary.\n\nASM has previously changed its public API but added a mechanism for API compatibility starting with version 4 of the\nlibrary. In order to avoid version conflicts with such older versions, Byte Buddy repackages the ASM dependency into its\nown namespace. If you want to use ASM directly, the `byte-buddy-dep` artifact offers a version of Byte Buddy with an\nexplicit dependency to ASM. When doing so, you **must** repackage *both* Byte Buddy and ASM into your namespace to avoid\nversion conflicts.\n\nPlease note the [security policy](https://github.com/raphw/byte-buddy/blob/master/SECURITY.md) of this project.\n\nByte Buddy supports execution on all JVM versions from version five and onwards in a single jar. This is done to ease \nthe development of Java agents which often require to support older, or unknown, applications which are not actively \nupdated. To allow for this while also supporting modern Java and features like CDS or class validation with stack \nmap frames, the main jars for Byte Buddy ship as multi-release jars that contain class files in version five and eight. \nAs a result, the jar size of Byte Buddy is higher as one would expect. Jar file size is not normally a problem, as\nthe majority of Byte Buddy's classes will never be loaded. Yet, file size might be an issue when distributing Java \nagents. As agents already need to be bundled as a single jar, it is therefore recommended to remove either the basic \nJava five version, or the multi-release Java eight version of the contained class files, to reduce this issue. This \nis supported by most build plugins for this purpose, such as the\n[Maven Shade plugin](https://maven.apache.org/plugins/maven-shade-plugin/shade-mojo.html#filters). Integration to the JDK's Class File API is contained in multi-release folders for version\n24 and later. These folders can be stripped without consequence, other than loosing support for the Class File API.\n\nLicense and development\n-----------------------\n\nByte Buddy is licensed under the liberal and business-friendly\n[*Apache Licence, Version 2.0*](https://www.apache.org/licenses/LICENSE-2.0.html) and is freely available on GitHub.\nAdditionally, the *byte-buddy* distribution bundles ASM which is released\nunder [a 3-clause BSD license](https://asm.ow2.io/license.html).\n\nByte Buddy binaries are published to the repositories of Maven Central and on JCenter. The artifacts signatures can be\nvalidated against [this PGP public key](https://keys.openpgp.org/search?q=rafael.wth@gmail.com) beginning with Byte\nBuddy 1.10.3. Older versions can be validated\nagainst [this older and weaker certificate](https://keyserver.ubuntu.com/pks/lookup?op=get\u0026search=0xf42b96b8648b5c4a1c43a62fbb2914c1fa0811c3)\n.\n\nThe project is built using \u003ca href=\"https://maven.apache.org/\"\u003eMaven\u003c/a\u003e. From your shell, cloning and building the\nproject would go something like this:\n\n```shell\ngit clone https://github.com/raphw/byte-buddy.git\ncd byte-buddy\nmvn package\n```\n\nOn these commands, Byte Buddy is cloned from GitHub and built on your machine. Further build options are listed in the\nroot POM file. Byte Buddy can be built with any JDK of at least version 6. It is however recommended to use a JDK of \nat least version 8 as the builds for version 6 and 7 require the usage of unencrypted HTTP. Its support is only meant\nfor running tests against this JDK version and can expose you to man-in-the-middle attacks. Therefore, these builds \nshould be avoided. Byte Buddy is currently tested for versions 6 and upwards of the JDK on CI servers.\n\nPlease use GitHub's [issue tracker](https://github.com/raphw/byte-buddy/issues) for reporting bugs. When committing\ncode, please provide test cases that prove the functionality of your features or that demonstrate a bug fix.\nFurthermore, make sure you are not breaking any existing test cases. If possible, please take the time to write some\ndocumentation. For feature requests or general feedback, you can also use the\n[issue tracker](https://github.com/raphw/byte-buddy/issues) or contact us on\n[our mailing list](https://groups.google.com/forum/#!forum/byte-buddy).\n\nSupporters\n----------\n\nThe work on Byte Buddy is also possible thanks to a row of supporters that have dedicated regular resources and\nattention to the project. Please take your time to have a look at those supporters and their offerings.\n\n\u003ca href=\"https://www.scienta.no\"\u003e\n\u003cimg src=\"https://bytebuddy.net/logos/scienta.png\" height=\"50\" alt=\"Scienta AS\"/\u003e \n\u003c/a\u003e\u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;\n\u003ca href=\"https://www.instana.com\"\u003e\n\u003cimg src=\"https://bytebuddy.net/logos/instana.png\" height=\"50\" alt=\"Instana\"/\u003e\n\u003c/a\u003e\u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;\n\u003ca href=\"https://www.sqreen.com\"\u003e\n\u003cimg src=\"https://bytebuddy.net/logos/sqreen.png\" height=\"50\" alt=\"Sqreen\"/\u003e\n\u003c/a\u003e\u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;\n\u003ca href=\"https://www.elastic.co\"\u003e\n\u003cimg src=\"https://bytebuddy.net/logos/elastic.png\" height=\"50\" alt=\"Elastic\"/\u003e\n\u003c/a\u003e\u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;\u0026nbsp;\n\u003ca href=\"https://www.spotify.com\"\u003e\n\u003cimg src=\"https://bytebuddy.net/logos/spotify.png\" height=\"50\" alt=\"Spotify\"/\u003e\n\u003c/a\u003e\n","funding_links":["https://github.com/sponsors/raphw","https://tidelift.com/funding/github/maven/net.bytebuddy:byte-buddy","https://tidelift.com/subscription/pkg/maven-net-bytebuddy-byte-buddy?utm_source=byte-buddy\u0026utm_medium=referral"],"categories":["Java","I. Development"],"sub_categories":["8. Code generation and changing byte code"],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fraphw%2Fbyte-buddy","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fraphw%2Fbyte-buddy","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fraphw%2Fbyte-buddy/lists"}