diff --git a/libs.asm/build.xml b/libs.asm/build.xml
new file mode 100644
--- /dev/null
+++ b/libs.asm/build.xml
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+
+Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
+
+Oracle and Java are registered trademarks of Oracle and/or its affiliates.
+Other names may be trademarks of their respective owners.
+
+
+The contents of this file are subject to the terms of either the GNU
+General Public License Version 2 only ("GPL") or the Common
+Development and Distribution License("CDDL") (collectively, the
+"License"). You may not use this file except in compliance with the
+License. You can obtain a copy of the License at
+http://www.netbeans.org/cddl-gplv2.html
+or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
+specific language governing permissions and limitations under the
+License.  When distributing the software, include this License Header
+Notice in each file and include the License file at
+nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
+particular file as subject to the "Classpath" exception as provided
+by Oracle in the GPL Version 2 section of the License file that
+accompanied this code. If applicable, add the following below the
+License Header, with the fields enclosed by brackets [] replaced by
+your own identifying information:
+"Portions Copyrighted [year] [name of copyright owner]"
+
+Contributor(s):
+
+The Original Software is NetBeans. The Initial Developer of the Original
+Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
+Microsystems, Inc. All Rights Reserved.
+
+If you wish your version of this file to be governed by only the CDDL
+or only the GPL Version 2, indicate your decision by adding
+"[Contributor] elects to include this software in this distribution
+under the [CDDL or GPL Version 2] license." If you do not indicate a
+single choice of license, a recipient has the option to distribute
+your version of this file under either the CDDL, the GPL Version 2 or
+to extend the choice of license to its licensees as provided above.
+However, if you add GPL Version 2 code and therefore, elected the GPL
+Version 2 license, then the option applies only if the new code is
+made subject to such option by the copyright holder.
+-->
+<project name="libs.asm" default="netbeans" basedir=".">
+    <import file="../nbbuild/templates/projectized.xml"/>
+</project>
diff --git a/libs.asm/external/asm-all-5.0.1-license.txt b/libs.asm/external/asm-all-5.0.1-license.txt
new file mode 100644
--- /dev/null
+++ b/libs.asm/external/asm-all-5.0.1-license.txt
@@ -0,0 +1,37 @@
+Name: OW2 ASM
+Version: 5.0.1
+License: INRIA license
+Origin: http://forge.ow2.org/project/download.php?group_id=23&file_id=19789
+OSR: 13078
+Description: Bytecode manipulation library
+
+*******************************************************************************
+* ASM: a very small and fast Java bytecode manipulation framework
+* Copyright (c) 2000-2011 INRIA, France Telecom
+* All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions
+* are met:
+* 1. Redistributions of source code must retain the above copyright
+*    notice, this list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright
+*    notice, this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holders nor the names of its
+*    contributors may be used to endorse or promote products derived from
+*    this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************
+
diff --git a/libs.asm/external/binaries-list b/libs.asm/external/binaries-list
new file mode 100644
--- /dev/null
+++ b/libs.asm/external/binaries-list
@@ -0,0 +1,1 @@
+2F7553F50B0D14ED811B849C282DA8C1FFC32AAE asm-all-5.0.1.jar
diff --git a/libs.asm/manifest.mf b/libs.asm/manifest.mf
new file mode 100644
--- /dev/null
+++ b/libs.asm/manifest.mf
@@ -0,0 +1,4 @@
+Manifest-Version: 1.0
+OpenIDE-Module: org.netbeans.libs.asm
+OpenIDE-Module-Localizing-Bundle: org/netbeans/libs/asm/Bundle.properties
+OpenIDE-Module-Specification-Version: 5.1
diff --git a/libs.asm/nbproject/project.properties b/libs.asm/nbproject/project.properties
new file mode 100644
--- /dev/null
+++ b/libs.asm/nbproject/project.properties
@@ -0,0 +1,48 @@
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+#
+# Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
+#
+# Oracle and Java are registered trademarks of Oracle and/or its affiliates.
+# Other names may be trademarks of their respective owners.
+#
+# The contents of this file are subject to the terms of either the GNU
+# General Public License Version 2 only ("GPL") or the Common
+# Development and Distribution License("CDDL") (collectively, the
+# "License"). You may not use this file except in compliance with the
+# License. You can obtain a copy of the License at
+# http://www.netbeans.org/cddl-gplv2.html
+# or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
+# specific language governing permissions and limitations under the
+# License.  When distributing the software, include this License Header
+# Notice in each file and include the License file at
+# nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
+# particular file as subject to the "Classpath" exception as provided
+# by Oracle in the GPL Version 2 section of the License file that
+# accompanied this code. If applicable, add the following below the
+# License Header, with the fields enclosed by brackets [] replaced by
+# your own identifying information:
+# "Portions Copyrighted [year] [name of copyright owner]"
+#
+# Contributor(s):
+#
+# The Original Software is NetBeans. The Initial Developer of the Original
+# Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
+# Microsystems, Inc. All Rights Reserved.
+#
+# If you wish your version of this file to be governed by only the CDDL
+# or only the GPL Version 2, indicate your decision by adding
+# "[Contributor] elects to include this software in this distribution
+# under the [CDDL or GPL Version 2] license." If you do not indicate a
+# single choice of license, a recipient has the option to distribute
+# your version of this file under either the CDDL, the GPL Version 2 or
+# to extend the choice of license to its licensees as provided above.
+# However, if you add GPL Version 2 code and therefore, elected the GPL
+# Version 2 license, then the option applies only if the new code is
+# made subject to such option by the copyright holder.
+
+javac.compilerargs=-Xlint -Xlint:-serial
+javac.source=1.7
+module.jar.dir=lib
+
+release.external/asm-all-5.0.1.jar=lib/ext/asm-5.0.1/asm-all-5.0.1.jar
+license.file=../external/asm-all-5.0.1-license.txt
diff --git a/libs.asm/nbproject/project.xml b/libs.asm/nbproject/project.xml
new file mode 100644
--- /dev/null
+++ b/libs.asm/nbproject/project.xml
@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+
+Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
+
+Oracle and Java are registered trademarks of Oracle and/or its affiliates.
+Other names may be trademarks of their respective owners.
+
+
+The contents of this file are subject to the terms of either the GNU
+General Public License Version 2 only ("GPL") or the Common
+Development and Distribution License("CDDL") (collectively, the
+"License"). You may not use this file except in compliance with the
+License. You can obtain a copy of the License at
+http://www.netbeans.org/cddl-gplv2.html
+or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
+specific language governing permissions and limitations under the
+License.  When distributing the software, include this License Header
+Notice in each file and include the License file at
+nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
+particular file as subject to the "Classpath" exception as provided
+by Oracle in the GPL Version 2 section of the License file that
+accompanied this code. If applicable, add the following below the
+License Header, with the fields enclosed by brackets [] replaced by
+your own identifying information:
+"Portions Copyrighted [year] [name of copyright owner]"
+
+Contributor(s):
+
+The Original Software is NetBeans. The Initial Developer of the Original
+Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
+Microsystems, Inc. All Rights Reserved.
+
+If you wish your version of this file to be governed by only the CDDL
+or only the GPL Version 2, indicate your decision by adding
+"[Contributor] elects to include this software in this distribution
+under the [CDDL or GPL Version 2] license." If you do not indicate a
+single choice of license, a recipient has the option to distribute
+your version of this file under either the CDDL, the GPL Version 2 or
+to extend the choice of license to its licensees as provided above.
+However, if you add GPL Version 2 code and therefore, elected the GPL
+Version 2 license, then the option applies only if the new code is
+made subject to such option by the copyright holder.
+-->
+<project xmlns="http://www.netbeans.org/ns/project/1">
+    <type>org.netbeans.modules.apisupport.project</type>
+    <configuration>
+        <data xmlns="http://www.netbeans.org/ns/nb-module-project/3">
+            <code-name-base>org.netbeans.libs.asm</code-name-base>
+            <module-dependencies/>
+            <public-packages>
+                <subpackages>org</subpackages>
+            </public-packages>
+            <class-path-extension>
+                <runtime-relative-path>ext/asm-5.0.1/asm-all-5.0.1.jar</runtime-relative-path>
+                <binary-origin>external/asm-all-5.0.1.jar</binary-origin>
+            </class-path-extension>
+<!--            <class-path-extension>
+                <runtime-relative-path>ext/asm-5.0.1/asm-5.0.1.jar</runtime-relative-path>
+                <binary-origin>external/asm-5.0.1.jar</binary-origin>
+            </class-path-extension>
+            <class-path-extension>
+                <runtime-relative-path>ext/asm-5.0.1/asm-commons-5.0.1.jar</runtime-relative-path>
+                <binary-origin>external/asm-commons-5.0.1.jar</binary-origin>
+            </class-path-extension>
+            <class-path-extension>
+                <runtime-relative-path>ext/asm-5.0.1/asm-util-5.0.1.jar</runtime-relative-path>
+                <binary-origin>external/asm-util-5.0.1.jar</binary-origin>
+            </class-path-extension>-->
+        </data>
+    </configuration>
+</project>
diff --git a/libs.asm/src/org/netbeans/libs/asm/Bundle.properties b/libs.asm/src/org/netbeans/libs/asm/Bundle.properties
new file mode 100644
--- /dev/null
+++ b/libs.asm/src/org/netbeans/libs/asm/Bundle.properties
@@ -0,0 +1,47 @@
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+#
+# Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
+#
+# Oracle and Java are registered trademarks of Oracle and/or its affiliates.
+# Other names may be trademarks of their respective owners.
+#
+# The contents of this file are subject to the terms of either the GNU
+# General Public License Version 2 only ("GPL") or the Common
+# Development and Distribution License("CDDL") (collectively, the
+# "License"). You may not use this file except in compliance with the
+# License. You can obtain a copy of the License at
+# http://www.netbeans.org/cddl-gplv2.html
+# or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
+# specific language governing permissions and limitations under the
+# License.  When distributing the software, include this License Header
+# Notice in each file and include the License file at
+# nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
+# particular file as subject to the "Classpath" exception as provided
+# by Oracle in the GPL Version 2 section of the License file that
+# accompanied this code. If applicable, add the following below the
+# License Header, with the fields enclosed by brackets [] replaced by
+# your own identifying information:
+# "Portions Copyrighted [year] [name of copyright owner]"
+#
+# Contributor(s):
+#
+# The Original Software is NetBeans. The Initial Developer of the Original
+# Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
+# Microsystems, Inc. All Rights Reserved.
+#
+# If you wish your version of this file to be governed by only the CDDL
+# or only the GPL Version 2, indicate your decision by adding
+# "[Contributor] elects to include this software in this distribution
+# under the [CDDL or GPL Version 2] license." If you do not indicate a
+# single choice of license, a recipient has the option to distribute
+# your version of this file under either the CDDL, the GPL Version 2 or
+# to extend the choice of license to its licensees as provided above.
+# However, if you add GPL Version 2 code and therefore, elected the GPL
+# Version 2 license, then the option applies only if the new code is
+# made subject to such option by the copyright holder.
+
+OpenIDE-Module-Name=OW2 ASM
+OpenIDE-Module-Display-Category=Libraries
+OpenIDE-Module-Short-Description=Bundles OW2 ASM (bytecode manipulation)
+OpenIDE-Module-Long-Description=\
+    This module bundles OW2 ASM (bytecode manipulation library).
diff --git a/nbbuild/cluster.properties b/nbbuild/cluster.properties
--- a/nbbuild/cluster.properties
+++ b/nbbuild/cluster.properties
@@ -166,6 +166,7 @@
 nb.cluster.bootstrap.depends=
 nb.cluster.bootstrap=\
         core.startup,\
+        libs.asm,\
         o.n.bootstrap,\
         openide.filesystems,\
         openide.modules,\
diff --git a/o.n.bootstrap/apichanges.xml b/o.n.bootstrap/apichanges.xml
--- a/o.n.bootstrap/apichanges.xml
+++ b/o.n.bootstrap/apichanges.xml
@@ -53,6 +53,23 @@
   </apidefs>
 
   <changes>
+    <change id="module.fragments">
+         <api name="launcher"/>
+         <summary>Ability to join other module</summary>
+         <version major="2" minor="69"/>
+         <date day="11" month="4" year="2014"/>
+         <author login="sdedic"/>
+         <compatibility addition="yes" binary="compatible" semantic="compatible" />
+         <description>
+         <p>
+             Module can be declared as <a href="@TOP@architecture-summary.html#modfrag">
+                 Module Fragment
+             </a> to join other module loader. Fragment classes may ask to be bytecode-patched
+             as superclasses of API classes to preserve compatibility.
+         </p>
+         </description>
+         <issue number="243561"/>
+     </change>
      <change id="patch.classes">
         <api name="launcher"/>
         <summary>Ability to patch classes</summary>
diff --git a/o.n.bootstrap/arch.xml b/o.n.bootstrap/arch.xml
--- a/o.n.bootstrap/arch.xml
+++ b/o.n.bootstrap/arch.xml
@@ -1533,10 +1533,33 @@
         have access to the class instance that is being defined yet.
         </p>
      </usecase>
+     
+     <usecase id="modfrag" name="Module Fragments">
+         <p>
+            This is a specific case of <a href="#usecase-patch">Patch Classes</a> use-case.
+            To maintain binary compatibility when <b>removing</b> methods from API classes,
+            the "removed" implementation is actually moved to a special class, which becomes
+            a <i>superclass</i> of the original API class. Such special classes should be
+            separated into a 'compat' module, which is only loaded in presence of old clients.
+         </p>
+         <p>
+            The compat module should declare it is a fragment of the original API module in its
+            <code>MANIFEST.MF</code>
+         </p>
+            <pre>
+OpenIDE-Module-Fragment-Host: orignal.module.codename
+            </pre>
+        <p>
+            which ensures contents of the compat module will be loaded using classloader
+            of the 'fragment host' module. The compat module will not get its own classloader.
+            The special class itself should be marked using <a href="@TOP@/org/netbeans/modules/PatchPublic.html">PatchPublic</a> annotation,
+            which causes it will be patched as superclass and inserted into the inheritance
+            chain.
+         </p>
+     </usecase>
  </answer>
 
 
-
 <!--
         <question id="arch-where" when="init">
             Where one can find sources for your module?
diff --git a/o.n.bootstrap/manifest.mf b/o.n.bootstrap/manifest.mf
--- a/o.n.bootstrap/manifest.mf
+++ b/o.n.bootstrap/manifest.mf
@@ -1,6 +1,6 @@
 Manifest-Version: 1.0
 OpenIDE-Module: org.netbeans.bootstrap/1
-OpenIDE-Module-Specification-Version: 2.68
+OpenIDE-Module-Specification-Version: 2.69
 OpenIDE-Module-Localizing-Bundle: org/netbeans/Bundle.properties
 OpenIDE-Module-Recommends: org.netbeans.NetigsoFramework
 
diff --git a/o.n.bootstrap/nbproject/project.properties b/o.n.bootstrap/nbproject/project.properties
--- a/o.n.bootstrap/nbproject/project.properties
+++ b/o.n.bootstrap/nbproject/project.properties
@@ -41,7 +41,7 @@
 # made subject to such option by the copyright holder.
 
 javac.compilerargs=-Xlint -Xlint:-serial
-javac.source=1.6
+javac.source=1.7
 module.jar.dir=lib
 module.jar.basename=boot.jar
 release.launcher/unix/nbexec=lib/nbexec
diff --git a/o.n.bootstrap/nbproject/project.xml b/o.n.bootstrap/nbproject/project.xml
--- a/o.n.bootstrap/nbproject/project.xml
+++ b/o.n.bootstrap/nbproject/project.xml
@@ -50,11 +50,19 @@
             <code-name-base>org.netbeans.bootstrap</code-name-base>
             <module-dependencies>
                 <dependency>
+                    <code-name-base>org.netbeans.libs.asm</code-name-base>
+                    <build-prerequisite/>
+                    <compile-dependency/>
+                    <run-dependency>
+                        <specification-version>5.0</specification-version>
+                    </run-dependency>
+                </dependency>
+                <dependency>
                     <code-name-base>org.openide.modules</code-name-base>
                     <build-prerequisite/>
                     <compile-dependency/>
                     <run-dependency>
-                        <specification-version>7.37</specification-version>
+                        <specification-version>7.44</specification-version>
                     </run-dependency>
                 </dependency>
                 <dependency>
diff --git a/o.n.bootstrap/src/org/netbeans/ChangeFirer.java b/o.n.bootstrap/src/org/netbeans/ChangeFirer.java
--- a/o.n.bootstrap/src/org/netbeans/ChangeFirer.java
+++ b/o.n.bootstrap/src/org/netbeans/ChangeFirer.java
@@ -45,7 +45,7 @@
 package org.netbeans;
 
 import java.util.logging.Level;
-import org.openide.util.Utilities;
+import org.openide.util.BaseUtilities;
 import java.util.*;
 
 /** Thread which fires changes in the modules.
@@ -144,10 +144,10 @@
         public boolean equals(Object o) {
             if (! (o instanceof Change)) return false;
             Change c = (Change) o;
-            return Utilities.compareObjects(prop, c.prop) &&
-                   Utilities.compareObjects(source, c.source) &&
-                   Utilities.compareObjects(old, c.old) &&
-                   Utilities.compareObjects(nue, c.nue);
+            return BaseUtilities.compareObjects(prop, c.prop) &&
+                   BaseUtilities.compareObjects(source, c.source) &&
+                   BaseUtilities.compareObjects(old, c.old) &&
+                   BaseUtilities.compareObjects(nue, c.nue);
         }
         public int hashCode() {
             return source.hashCode() ^ (prop == null ? 0 : prop.hashCode());
diff --git a/o.n.bootstrap/src/org/netbeans/JarClassLoader.java b/o.n.bootstrap/src/org/netbeans/JarClassLoader.java
--- a/o.n.bootstrap/src/org/netbeans/JarClassLoader.java
+++ b/o.n.bootstrap/src/org/netbeans/JarClassLoader.java
@@ -90,7 +90,7 @@
 import java.util.logging.Logger;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipException;
-import org.openide.util.Utilities;
+import org.openide.util.BaseUtilities;
 
 /**
  * A ProxyClassLoader capable of loading classes from a set of jar files
@@ -176,7 +176,7 @@
     }
 
     final void addURL(URL location) throws IOException, URISyntaxException {
-        File f = Utilities.toFile(location.toURI());
+        File f = BaseUtilities.toFile(location.toURI());
         assert f.exists() : "URL must be existing local file: " + location;
 
         List<Source> arr = new ArrayList<Source>(Arrays.asList(sources));
@@ -210,7 +210,23 @@
             arr[3], arr[4], arr[5], sealBase);
     }
     
-    private Boolean patchingBytecode;
+    /**
+     * Bytecode patching helper
+     */
+    private PatchByteCode patchingBytecode;
+    
+    byte[] getClassData(String name) {
+        String path = name.replace('.', '/').concat(".class"); // NOI18N
+        for( int i=0; i<sources.length; i++ ) {
+            final Source src = sources[i];
+            byte[] data = src.getClassData(path);
+            if (data != null) {
+                return data;
+            }
+        }
+        return null;
+    }
+    
     @Override
     protected Class doLoadClass(String pkgName, String name) {
         String path = name.replace('.', '/').concat(".class"); // NOI18N
@@ -223,18 +239,17 @@
 
             synchronized (sources) {
                 if (patchingBytecode == null) {
-                    patchingBytecode = findResource("META-INF/.bytecodePatched") != null; // NOI18N
-                    if (patchingBytecode) {
+                    Enumeration<URL> res = findResources("META-INF/.bytecodePatched"); // NOI18N
+                    if (res.hasMoreElements()) {
                         LOGGER.log(Level.FINE, "Patching bytecode in {0}", this);
                     }
+                    patchingBytecode = PatchByteCode.fromStream(res, this);
                 }
             }
-            if (patchingBytecode) {
-                try {
-                    data = PatchByteCode.patch(data);
-                } catch (Exception x) {
-                    LOGGER.log(Level.INFO, "Could not bytecode-patch " + name, x);
-                }
+            try {
+                data = patchingBytecode.apply(name, data);
+            } catch (Exception x) {
+                LOGGER.log(Level.INFO, "Could not bytecode-patch " + name, x);
             }
             
             // Note that we assume that if we are defining a class in this package,
@@ -479,7 +494,7 @@
                     return this;
                 }
             }
-            return "jar:" + Utilities.toURI(new VFile()) + "!/"; // NOI18N
+            return "jar:" + BaseUtilities.toURI(new VFile()) + "!/"; // NOI18N
         }
 
         @Override
@@ -823,7 +838,7 @@
             String tmp = getURL().toExternalForm();
             if (tmp.startsWith("jar:file:") && tmp.endsWith("!/")) {
                 String path = tmp.substring(9, tmp.length() - 2).replace("%20", " ");
-                if (Utilities.isWindows()) {
+                if (BaseUtilities.isWindows()) {
                     if (path.startsWith("/")) { // NOI18N
                         path = path.substring(1);
                     }
@@ -839,7 +854,7 @@
         File dir;
         
         DirSource(File file) throws MalformedURLException {
-            super(Utilities.toURI(file).toURL());
+            super(BaseUtilities.toURI(file).toURL());
             dir = file;
         }
         
@@ -849,7 +864,7 @@
 
         protected URL doGetResource(String name) throws MalformedURLException {
             File resFile = new File(dir, name);
-            return resFile.exists() ? Utilities.toURI(resFile).toURL() : null;
+            return resFile.exists() ? BaseUtilities.toURI(resFile).toURL() : null;
         }
         
         protected byte[] readClass(String path) throws IOException {
@@ -972,7 +987,7 @@
             AGAIN: for (;;) try {
                 final URI uri = new URI(filePath);
                 if (uri.getScheme().equals("file")) {
-                    jar = Utilities.toFile(uri).getPath();
+                    jar = BaseUtilities.toFile(uri).getPath();
                 } else {
                     jar = null;
                 }
diff --git a/o.n.bootstrap/src/org/netbeans/LocaleVariants.java b/o.n.bootstrap/src/org/netbeans/LocaleVariants.java
--- a/o.n.bootstrap/src/org/netbeans/LocaleVariants.java
+++ b/o.n.bootstrap/src/org/netbeans/LocaleVariants.java
@@ -51,7 +51,7 @@
 import java.util.logging.Logger;
 import org.openide.modules.InstalledFileLocator;
 import org.openide.util.NbBundle;
-import org.openide.util.Utilities;
+import org.openide.util.BaseUtilities;
 
 final class LocaleVariants implements Stamps.Updater {
     private static final Logger err = Util.err;
@@ -237,7 +237,7 @@
     static synchronized String[] getLocalizingSuffixesFast() {
         if (suffixes == null ||
                 Locale.getDefault() != lastLocale ||
-                !Utilities.compareObjects(NbBundle.getBranding(), lastBranding)) {
+                !BaseUtilities.compareObjects(NbBundle.getBranding(), lastBranding)) {
             List<String> _suffixes = new ArrayList<String>();
             Iterator<String> it = NbBundle.getLocalizingSuffixes();
             while (it.hasNext()) {
diff --git a/o.n.bootstrap/src/org/netbeans/Module.java b/o.n.bootstrap/src/org/netbeans/Module.java
--- a/o.n.bootstrap/src/org/netbeans/Module.java
+++ b/o.n.bootstrap/src/org/netbeans/Module.java
@@ -264,6 +264,10 @@
         return data().getCodeName();
     }
     
+    String getFragmentHostCodeName() {
+        return data().getFragmentHostCodeName();
+    }
+    
     @Override
     public String getCodeNameBase() {
         String cnb = mgr.cnbFor(getJarFile());
diff --git a/o.n.bootstrap/src/org/netbeans/ModuleData.java b/o.n.bootstrap/src/org/netbeans/ModuleData.java
--- a/o.n.bootstrap/src/org/netbeans/ModuleData.java
+++ b/o.n.bootstrap/src/org/netbeans/ModuleData.java
@@ -61,6 +61,7 @@
 import java.util.logging.Logger;
 import org.netbeans.Module.PackageExport;
 import org.openide.modules.Dependency;
+import org.openide.modules.PatchFor;
 import org.openide.modules.SpecificationVersion;
 import org.openide.util.Exceptions;
 import org.openide.util.NbBundle;
@@ -85,7 +86,7 @@
     private final Dependency[] dependencies;
     private final Set<String> coveredPackages;
     private final String agentClass;
-    
+    private final String fragmentHostCodeName;
     
     ModuleData(Manifest mf, Module forModule) throws InvalidException {
         Attributes attr = mf.getMainAttributes();
@@ -211,6 +212,23 @@
                 this.friendNames = set;
             }
             this.dependencies = initDeps(forModule, deps, attr);
+            String classLoader = attr.getValue(PatchFor.MANIFEST_FRAGMENT_HOST); // NOI18N
+            if (classLoader != null) {
+                Object[] clParse = Util.parseCodeName(classLoader);
+                String frag = (String)clParse[0];
+                if (frag != null) {
+                    if ((frag = frag.trim()).isEmpty()) {
+                        frag = null;
+                    }
+                }
+                this.fragmentHostCodeName = frag;
+                if (verifyCNBs && frag != null) {
+                    // Indirect way of checking syntax:
+                    Dependency.create(Dependency.TYPE_MODULE, fragmentHostCodeName);
+                }
+            } else {
+                fragmentHostCodeName = null;
+            }
         } catch (IllegalArgumentException iae) {
             throw (InvalidException) new InvalidException("While parsing " + codeName + " a dependency attribute: " + iae.toString()).initCause(iae); // NOI18N
         }
@@ -249,6 +267,7 @@
         this.dependencies = computeImported(mf.getMainAttributes());
         this.coveredPackages = new HashSet<String>();
         this.agentClass = getMainAttribute(mf, "Agent-Class"); // NOI18N
+        this.fragmentHostCodeName = null;
     }
     
     ModuleData(ObjectInput dis) throws IOException {
@@ -265,6 +284,11 @@
             this.specVers = new SpecificationVersion(dis.readUTF());
             this.publicPackages = Module.PackageExport.read(dis);
             this.agentClass = dis.readUTF();
+            String s = dis.readUTF();
+            if (s != null) {
+                s = s.trim();
+            }
+            this.fragmentHostCodeName = s == null || s.isEmpty() ? null : s;
         } catch (ClassNotFoundException cnfe) {
             throw new IOException(cnfe);
         }
@@ -283,6 +307,7 @@
         dos.writeUTF(specVers != null ? specVers.toString() : "0");
         Module.PackageExport.write(dos, publicPackages);
         dos.writeUTF(agentClass == null ? "" : agentClass);
+        dos.writeUTF(fragmentHostCodeName == null ? "" : fragmentHostCodeName);
     }
 
     private Dependency[] computeImported(Attributes attr) {
@@ -428,6 +453,10 @@
         forModule.refineDependencies(deps);
         return deps.toArray(new Dependency[deps.size()]);
     }
+    
+    final String getFragmentHostCodeName() {
+        return fragmentHostCodeName;
+    }
 
     final String getCodeName() {
         return codeName;
diff --git a/o.n.bootstrap/src/org/netbeans/ModuleManager.java b/o.n.bootstrap/src/org/netbeans/ModuleManager.java
--- a/o.n.bootstrap/src/org/netbeans/ModuleManager.java
+++ b/o.n.bootstrap/src/org/netbeans/ModuleManager.java
@@ -116,6 +116,11 @@
     // the same, indexed by code name base
     private final Map<String,Module> modulesByName = new HashMap<String,Module>(100);
 
+    /**
+     * Modules whose contents is injected into 
+     */
+    private final Map<String, Collection<Module>> fragmentModules = new HashMap<String, Collection<Module>>(5);
+
     // for any module, set of known failed dependencies or problems,
     // or null if this has not been computed yet
     private final Object MODULE_PROBLEMS_LOCK = new Object();
@@ -825,10 +830,40 @@
         return installer.refineProvides (m);
     }
     /** Used by Module to communicate with the ModuleInstaller re. classloader. */
-    public void refineClassLoader(Module m, List parents) {
+    public ClassLoader refineClassLoader(Module m, List parents) {
         // #27853:
         installer.refineClassLoader(m, parents);
+        // if fragment, integrate into the host's classloader. Should be called under mutex()
+        String fragmentHost = m.getFragmentHostCodeName();
+        if (fragmentHost == null) {
+            return null;
+        }
+        Module theHost = modulesByName.get(fragmentHost);
+        if (theHost == null) {
+            throw new IllegalStateException("Missing hosting module " + fragmentHost + " for fragment " + m.getCodeName());
+        }
+        return theHost.getClassLoader();
     }
+    
+    /**
+     * Refines the module's own path with patches from other modules
+     * @param m the module
+     * @param path the ordered list of classpath fragments
+     */
+    void refineModulePath(Module m, List<File> path) {
+        String cnb = m.getCodeNameBase();
+        Collection<Module> injectList = fragmentModules.get(cnb);
+        if (injectList == null) {
+            return;
+        }
+        for (Module inject : injectList) {
+            Util.err.log(Level.FINER, "Compat: injecting contents of fragment " + inject.getCodeNameBase() + " into " + m.getCodeNameBase());
+            List<File> allJars = inject.getAllJars();
+            // PENDING: shouldn't we add those jars first, so they take precedence ?
+            path.addAll(allJars);
+        }
+    }
+    
     /** Use by OneModuleClassLoader to communicate with the ModuleInstaller re. masking. */
     public boolean shouldDelegateResource(Module m, Module parent, String pkg) {
         // Cf. #19621:
@@ -903,6 +938,7 @@
         modules.add(m);
         modulesByName.put(m.getCodeNameBase(), m);
         providersOf.possibleProviderAdded(m);
+        
         lookup.add(m);
         firer.created(m);
         firer.change(new ChangeFirer.Change(this, PROP_MODULES, null, null));
@@ -913,6 +949,55 @@
         clearProblemCache();
         firer.fire();
     }
+    
+    /**
+     * Attaches a fragment to an existing module. The hosting module must NOT
+     * be already enabled, otherwise an exception will be thrown. Enabled module
+     * may have some classes already loaded, and they cannot be patched.
+     * 
+     * @param m module to attach if it is a fragment
+     */
+    private void attachModuleFragment(Module m) {
+        String codeNameBase = m.getFragmentHostCodeName();
+        if (codeNameBase == null) {
+            return;
+        }
+        Module host = modulesByName.get(codeNameBase);
+        if (host != null && host.isEnabled()) {
+            throw new IllegalStateException("Module " + host.getCodeName() + " is already enabled");
+        }
+        Collection<Module> frags = fragmentModules.get(codeNameBase);
+        if (frags == null) {
+            frags = new ArrayList<Module>(1);
+            fragmentModules.put(codeNameBase, frags);
+        }
+        frags.add(m);
+        
+    }
+    
+    /**
+     * Removes a fragment module. Throws an exception if the fragment's
+     * host is already enabled and its classloader may have loaded fragment's
+     * contents.
+     * <p/>
+     * The method does nothing for non-fragment modules
+     * 
+     * @param m the module to remove
+     */
+    private void removeFragmentFromHost(Module m) {
+        String fragHost = m.getFragmentHostCodeName();
+        if (fragHost == null) {
+            return;
+        }
+        Module hostMod = modulesByName.get(fragHost);
+        if (hostMod != null && hostMod.isEnabled()) {
+            throw new IllegalStateException("Host module " + m.getCodeName() + " was loaded, cannot remove fragment");
+        }
+        Collection<Module> frags = fragmentModules.get(fragHost);
+        if (frags != null) {
+            frags.remove(m);
+        }
+    }
 
     /** Remove a module from the managed set.
      * Must be disabled first.
@@ -923,6 +1008,7 @@
         if (m.isFixed()) throw new IllegalArgumentException("fixed module: " + m); // NOI18N
         if (m.isEnabled()) throw new IllegalArgumentException("enabled module: " + m); // NOI18N
         ev.log(Events.DELETE_MODULE, m);
+        removeFragmentFromHost(m);
         modules.remove(m);
         modulesByName.remove(m.getCodeNameBase());
         providersOf.possibleProviderRemoved(m);
@@ -1050,6 +1136,14 @@
         ev.log(Events.START_ENABLE_MODULES, toEnable);
         netigso.willEnable(toEnable);
         for (;;) {
+            // first connect fragments to their hosts, so classloaders are populated
+            for (Module m: toEnable) {
+                if (m.isEnabled()) {
+                    continue;
+                }
+                // store information from fragment modules for early initialization of hosting classlaoder:
+                attachModuleFragment(m);
+            }
             // Actually turn on the listed modules.
             // List of modules that need to be "rolled back".
             LinkedList<Module> fallback = new LinkedList<Module>();
diff --git a/o.n.bootstrap/src/org/netbeans/PatchByteCode.java b/o.n.bootstrap/src/org/netbeans/PatchByteCode.java
--- a/o.n.bootstrap/src/org/netbeans/PatchByteCode.java
+++ b/o.n.bootstrap/src/org/netbeans/PatchByteCode.java
@@ -44,7 +44,28 @@
 
 package org.netbeans;
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
 import java.io.UnsupportedEncodingException;
+import java.net.URL;
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Properties;
+import java.util.logging.Logger;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.signature.SignatureReader;
+import org.objectweb.asm.signature.SignatureVisitor;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.AnnotationNode;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
 import org.openide.modules.PatchedPublic;
 
 /**
@@ -54,17 +75,350 @@
  * @see #patch
  */
 public final class PatchByteCode {
-
+    private static final Logger LOG = Logger.getLogger(PatchByteCode.class.getName());
+    
     private static final byte[] RUNTIME_INVISIBLE_ANNOTATIONS, PATCHED_PUBLIC;
+    private static final String DESC_CTOR_ANNOTATION = "Lorg/openide/modules/ConstructorDelegate;";
+    private static final String DESC_PATCHED_PUBLIC_ANNOTATION = "Lorg/openide/modules/PatchedPublic;";
+    private static final String DESC_DEFAULT_CTOR = "()V";
+    private static final String CONSTRUCTOR_NAME = "<init>"; // NOI18N
+    private static final String PREFIX_EXTEND = "extend."; // NOI18N
+    
     static {
         try {
             RUNTIME_INVISIBLE_ANNOTATIONS = "RuntimeInvisibleAnnotations".getBytes("UTF-8"); // NOI18N
-            PATCHED_PUBLIC = ("L" + PatchedPublic.class.getName().replace('.', '/') + ";").getBytes("UTF-8"); // NOI18N
+            PATCHED_PUBLIC = DESC_PATCHED_PUBLIC_ANNOTATION.getBytes("UTF-8"); // NOI18N
         } catch (UnsupportedEncodingException x) {
             throw new ExceptionInInitializerError(x);
         }
     }
+    
+    /**
+     * Shared instance, which does just nothing
+     */
+    private static final PatchByteCode NOP = new PatchByteCode(false, null, null);
+    
+    /**
+     * Shared instance, that performs a very fast PatchedPublic patch on the loaded class
+     */
+    private static final PatchByteCode PUBLIC_ONLY = new PatchByteCode(true, null, null);
+    
+    private final boolean patchPublic;
+    private final Map<String, String> classToExtend;
+    private final ClassLoader theClassLoader;
+    
+    private PatchByteCode() {
+        this(false, null, null);
+    }
+    
+    private PatchByteCode(boolean pub, Map<String, String> classToExtend, ClassLoader ldr) {
+        this.patchPublic = pub;
+        this.classToExtend = classToExtend;
+        this.theClassLoader = ldr;
+    }
+    
+    private void load(URL stream) throws IOException {
+        try (InputStream istm = stream.openStream()) {
+            Properties props = new Properties();
+            props.load(new InputStreamReader(istm, "UTF-8")); // NOI18N
+            
+            Enumeration<String> en = (Enumeration<String>)props.propertyNames();
+            
+            while (en.hasMoreElements()) {
+                String pn = en.nextElement();
+                if (pn.startsWith(PREFIX_EXTEND)) {
+                    String toExtend = pn.substring(PREFIX_EXTEND.length());
+                    String extendWith = props.getProperty(pn);
+                    
+                    String old;
+                    
+                    if ((old = classToExtend.put(toExtend, extendWith)) != null) {
+                        throw new IOException("Multiple extend instructions for class" + toExtend + ": " + extendWith + " and " + old);
+                    }
+                }
+            }
+        }
+    }
+    
+    private PatchByteCode purify() {
+        if (classToExtend == null || classToExtend.isEmpty()) {
+            return PUBLIC_ONLY;
+        } else {
+            return this;
+        }
+    }
+    
+    static PatchByteCode fromStream(Enumeration<URL> streams, ClassLoader ldr) {
+        PatchByteCode pb = new PatchByteCode(false, new HashMap<String, String>(3), ldr);
+        boolean found = false;
+        while (streams.hasMoreElements()) {
+            URL stream = streams.nextElement();
+            try {
+                pb.load(stream);
+            } catch (IOException ex) {
+                // TODO: log
+            }
+            found = true;
+        }
+        
+        return found ? pb.purify() : NOP;
+    }
 
+    byte[] apply(String className, byte[] data) throws IOException {
+        if (patchPublic) {
+            return patch(data);
+        } else if (classToExtend == null) {
+            return data;
+        }
+        // more thorough analysis is needed.
+        String extender = classToExtend.get(className);
+        if (extender == null) {
+            return patch(data);
+        }
+        // must analyze the extender class, as some annotations there may trigger 
+        ClassReader clr = new ClassReader(data);
+        ClassWriter wr = new ClassWriter(clr, 0);
+        ClassNode theClass = new ClassNode();
+        
+        clr.accept(theClass, 0);
+        
+        MethodNode defCtor = null;
+        
+        String extInternalName = extender.replace(".", "/"); // NOI18N
+        
+        // patch the superclass
+        theClass.superName = extInternalName;
+        String resName = extInternalName + ".class"; // NOI18N
+        
+        try (InputStream istm = theClassLoader.getResourceAsStream(resName)) {
+            if (istm == null) {
+                throw new IOException("Could not find classfile for extender class"); // NOI18N
+            }
+            ClassReader extenderReader = new ClassReader(istm);
+            ClassNode extenderClass = new ClassNode();
+            extenderReader.accept(extenderClass, ClassReader.SKIP_FRAMES);
+            
+            // search for a no-arg ctor, replace all invokespecial calls in ctors
+            for (MethodNode m : (Collection<MethodNode>)theClass.methods) {
+                if (CONSTRUCTOR_NAME.equals(m.name)) {
+                    if (DESC_DEFAULT_CTOR.equals(m.desc)) { // NOI18N
+                        defCtor = m;
+                    }
+                    replaceSuperCtorCalls(theClass, extenderClass, m);
+                }
+            }
+            for (Object o : extenderClass.methods) {
+                MethodNode mn = (MethodNode)o;
+
+                if (mn.invisibleAnnotations != null && (mn.access & Opcodes.ACC_STATIC) > 0) {
+                    // constructor, possibly annotated
+                    for (AnnotationNode an : (Collection<AnnotationNode>)mn.invisibleAnnotations) {
+                        if (DESC_CTOR_ANNOTATION.equals(an.desc)) {
+                            delegateToFactory(extenderClass, mn, theClass, defCtor);
+                            break;
+                        }
+                    }
+                }
+            }
+            
+            for (MethodNode mn : (Collection<MethodNode>)theClass.methods) {
+                if (mn.invisibleAnnotations == null) {
+                    continue;
+                }
+                for (AnnotationNode an : (Collection<AnnotationNode>)mn.invisibleAnnotations) {
+                    if (DESC_PATCHED_PUBLIC_ANNOTATION.equals(an.desc)) {
+                        mn.access = (mn.access & ~(Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED)) | Opcodes.ACC_PUBLIC;
+                        break;
+                    }
+                }
+            }
+        }
+        
+        theClass.accept(wr);
+        byte[] result = wr.toByteArray();
+        return result;
+    }
+
+    /**
+     * Replaces class references in super constructor invocations.
+     * Must not replace references in this() constructor invocations.
+     * 
+     * @param theClass the class being patched
+     * @param extenderClass the injected superclass
+     * @param mn method to process
+     */
+    private void replaceSuperCtorCalls(final ClassNode theClass, final ClassNode extenderClass, MethodNode mn) {
+        for (Iterator it = mn.instructions.iterator(); it.hasNext(); ) {
+            AbstractInsnNode aIns = (AbstractInsnNode)it.next();
+            if (aIns.getOpcode() == Opcodes.INVOKESPECIAL) {
+                MethodInsnNode mins = (MethodInsnNode)aIns;
+                if (CONSTRUCTOR_NAME.equals(mins.name) && !mins.owner.equals(theClass.name)) {
+                    // replace with the extender class name
+                    mins.owner = extenderClass.name;
+                }
+                break;
+            }
+        }
+    }
+    
+    /**
+     * No-op singature visitor
+     */
+    private static class NullSignVisitor extends SignatureVisitor {
+        public NullSignVisitor() {
+            super(Opcodes.ASM5);
+        }
+    }
+    
+    /**
+     * Pushes parameters with correct opcodes that correspond to the
+     * method's signature. Assumes that the first parameter is the
+     * object's class itself.
+     */
+    private static class CallParametersWriter extends SignatureVisitor {
+        private final MethodNode mn;
+        private int localSize;
+        
+        /**
+         * Adds opcodes to the method's code
+         * 
+         * @param mn method to generate
+         * @param firstSelf if true, assumes the first parameter is reference to self and will generate aload_0
+         */
+        public CallParametersWriter(MethodNode mn, boolean firstSelf) {
+            super(Opcodes.ASM5);
+            this.mn = mn;
+            this.paramIndex = firstSelf ? 0 : 1;
+        }
+        
+        private int paramIndex = 1;
+
+        @Override
+        public void visitEnd() {
+            // end of classtype
+            mn.visitVarInsn(Opcodes.ALOAD, paramIndex++);
+            localSize++;
+        }
+
+        @Override
+        public void visitBaseType(char c) {
+            int idx = paramIndex++;
+            int opcode;
+
+            switch (c) {
+                // two-word data
+                case 'J': opcode = Opcodes.LLOAD; paramIndex++; localSize++; break;
+                case 'D': opcode = Opcodes.DLOAD; paramIndex++; localSize++; break;
+                // float has a special opcode
+                case 'F': opcode = Opcodes.FLOAD; break;
+                default: opcode = Opcodes.ILOAD; break;
+
+            }
+            mn.visitVarInsn(opcode, idx);
+            localSize++;
+        }
+
+        @Override
+        public SignatureVisitor visitTypeArgument(char c) {
+            return new NullSignVisitor();
+        }
+
+        @Override
+        public void visitTypeArgument() {}
+
+        @Override
+        public void visitInnerClassType(String string) {}
+
+        @Override
+        public void visitClassType(String string) {}
+
+        @Override
+        public SignatureVisitor visitArrayType() {
+            mn.visitVarInsn(Opcodes.ALOAD, paramIndex++);
+            return new NullSignVisitor();
+        }
+
+        @Override
+        public void visitTypeVariable(String string) {}
+
+        @Override
+        public SignatureVisitor visitExceptionType() {
+            return new NullSignVisitor();
+        }
+
+        @Override
+        public SignatureVisitor visitReturnType() {
+            return new NullSignVisitor();
+        }
+
+        @Override
+        public SignatureVisitor visitParameterType() {
+            return this;
+        }
+
+        @Override
+        public SignatureVisitor visitInterface() {
+            return null;
+        }
+
+        @Override
+        public SignatureVisitor visitSuperclass() {
+            return null;
+        }
+
+        @Override
+        public SignatureVisitor visitInterfaceBound() {
+            return new NullSignVisitor();
+        }
+
+        @Override
+        public SignatureVisitor visitClassBound() {
+            return new NullSignVisitor();
+        }
+
+        @Override
+        public void visitFormalTypeParameter(String string) {
+            super.visitFormalTypeParameter(string); //To change body of generated methods, choose Tools | Templates.
+        }
+
+    }
+
+    private void delegateToFactory(ClassNode targetClass, MethodNode targetMethod, ClassNode clazz,
+            MethodNode noArgCtor) {
+        String desc = targetMethod.desc;
+        // assume the first parameter is the class:
+        int nextPos = desc.indexOf(';', 2); // NOI18N
+        desc = "(" + desc.substring(nextPos + 1); // NOI18N
+        MethodNode mn = new MethodNode(Opcodes.ASM5, 
+                targetMethod.access & (~Opcodes.ACC_STATIC), CONSTRUCTOR_NAME,
+                desc,
+                targetMethod.signature,
+                (String[])targetMethod.exceptions.toArray(new String[targetMethod.exceptions.size()]));
+        
+        mn.visibleAnnotations = targetMethod.visibleAnnotations;
+        mn.visibleParameterAnnotations = targetMethod.visibleParameterAnnotations;
+        mn.parameters = targetMethod.parameters;
+        mn.exceptions = targetMethod.exceptions;
+        mn.visitCode();
+        // this();
+        mn.visitVarInsn(Opcodes.ALOAD, 0);
+        mn.visitMethodInsn(Opcodes.INVOKESPECIAL, 
+                clazz.name, 
+                noArgCtor.name, noArgCtor.desc, false);
+        
+        // push parameters
+        SignatureReader r = new SignatureReader(targetMethod.desc);
+        CallParametersWriter callWr = new CallParametersWriter(mn, true);
+        r.accept(callWr);
+        mn.visitMethodInsn(Opcodes.INVOKESTATIC, targetClass.name, targetMethod.name, targetMethod.desc, false);
+        
+        mn.visitInsn(Opcodes.RETURN);
+        mn.maxStack = callWr.localSize;
+        mn.maxLocals = callWr.localSize;
+        
+        clazz.methods.add(mn);
+    }
+    
     /**
      * Patches a class if it is needed.
      * @param arr the bytecode
diff --git a/o.n.bootstrap/src/org/netbeans/StandardModule.java b/o.n.bootstrap/src/org/netbeans/StandardModule.java
--- a/o.n.bootstrap/src/org/netbeans/StandardModule.java
+++ b/o.n.bootstrap/src/org/netbeans/StandardModule.java
@@ -78,7 +78,7 @@
 import org.openide.modules.InstalledFileLocator;
 import org.openide.util.Exceptions;
 import org.openide.util.NbBundle;
-import org.openide.util.Utilities;
+import org.openide.util.BaseUtilities;
 
 /** Object representing one module, possibly installed.
  * Responsible for opening of module JAR file; reading
@@ -542,15 +542,22 @@
         }
         
         ((StandardModuleData)data()).addCp(classp);
+
+        // possibly inject some patches
+        getManager().refineModulePath(this, classp);
         
-        // #27853:
-        getManager().refineClassLoader(this, loaders);
-        
-        try {
-            classloader = createNewClassLoader(classp, loaders);
-        } catch (IllegalArgumentException iae) {
-            // Should not happen, but just in case.
-            throw (IOException) new IOException(iae.toString()).initCause(iae);
+        // #27853
+        ClassLoader cld = getManager().refineClassLoader(this, loaders);
+        // the classloader may be shared, if this module is a fragment
+        if (cld != null) {
+            classloader = cld;
+        } else {
+            try {
+                classloader = createNewClassLoader(classp, loaders);
+            } catch (IllegalArgumentException iae) {
+                // Should not happen, but just in case.
+                throw (IOException) new IOException(iae.toString()).initCause(iae);
+            }
         }
     }
     
@@ -667,7 +674,7 @@
                 return lib.getAbsolutePath();
             }
             
-            if( Utilities.isMac() ) {
+            if( BaseUtilities.isMac() ) {
                 String jniMapped = mapped.replaceFirst("\\.dylib$",".jnilib");
                 lib = ifl.locate("modules/lib/" + jniMapped, getCodeNameBase(), false); // NOI18N
                 if (lib != null) {
diff --git a/o.n.bootstrap/test/unit/src/org/netbeans/PatchByteCodeTest.java b/o.n.bootstrap/test/unit/src/org/netbeans/PatchByteCodeTest.java
--- a/o.n.bootstrap/test/unit/src/org/netbeans/PatchByteCodeTest.java
+++ b/o.n.bootstrap/test/unit/src/org/netbeans/PatchByteCodeTest.java
@@ -45,9 +45,15 @@
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
 import java.lang.reflect.Member;
 import java.lang.reflect.Modifier;
+import java.net.URL;
+import java.util.Enumeration;
 import org.netbeans.junit.NbTestCase;
+import org.openide.modules.ConstructorDelegate;
+import org.openide.modules.PatchFor;
 import org.openide.modules.PatchedPublic;
 
 public class PatchByteCodeTest extends NbTestCase {
@@ -65,6 +71,26 @@
         @PatchedPublic
         private void m2() {}
     }
+    
+    public static class Superclazz {
+        public int val;
+    }
+    
+    public static class CAPI extends Superclazz {
+        public int otherVal;
+        
+        public CAPI() {
+            otherVal = 1;
+        }
+    }
+    
+    @PatchFor(CAPI.class)
+    public static class CompatAPI extends Superclazz {
+        @ConstructorDelegate
+        protected static void createAPI(CompatAPI inst, int val2) {
+            inst.val = val2;
+        }
+    }
 
     public void testPatchingPublic() throws Exception {
         Class<?> c = new L().loadClass(C.class.getName());
@@ -83,6 +109,41 @@
         assertEquals(Modifier.PUBLIC, m.getModifiers() & Modifier.PUBLIC);
         assertEquals(0, m.getModifiers() & Modifier.PRIVATE);
     }
+    
+    public void testPatchSuperclass() throws Exception {
+        Class<?> c = new L().loadClass(CAPI.class.getName());
+        assertNotSame(c, CAPI.class);
+        
+        Class s = c.getSuperclass();
+        assertNotSame(s, Object.class);
+        assertEquals(CompatAPI.class.getName(), s.getName());
+    }
+    
+    public void testGeneratedConstructor() throws Exception {
+        Class<?> c = new L().loadClass(CAPI.class.getName());
+        Member m = c.getDeclaredConstructor(int.class);
+        assertEquals(Modifier.PROTECTED, m.getModifiers() & (Modifier.PRIVATE | Modifier.PROTECTED | Modifier.PRIVATE));
+    }
+    
+    public void testExecutingConstructor() throws Exception {
+        ClassLoader l = new L();
+        Class<?> c = l.loadClass(CAPI.class.getName());        
+        Member m = c.getDeclaredConstructor(int.class);
+        Constructor ctor = (Constructor)m;
+        ctor.setAccessible(true);
+        
+        Object o = ctor.newInstance(5);
+        assertSame(c, o.getClass());
+        assertTrue("Invalid API superclass", Superclazz.class.isInstance(o));
+        
+        assertEquals("@ConstructorDelegate method did not execute", 5, ((Superclazz)o).val);
+        
+        Field f = o.getClass().getField("otherVal");
+        Object v = f.get(o);
+        assertEquals("Patched API constructor did not execute", v, 1);
+    }
+    
+    
 
     private static class L extends ClassLoader {
 
@@ -92,7 +153,7 @@
 
         @Override
         protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
-            if (name.startsWith(PatchByteCodeTest.class.getName() + "$")) {
+            if (name.startsWith(PatchByteCodeTest.class.getName() + "$C")) {
                 ByteArrayOutputStream baos = new ByteArrayOutputStream();
                 InputStream in = getResourceAsStream(name.replace('.', '/') + ".class");
                 int r;
@@ -103,7 +164,13 @@
                 } catch (IOException x) {
                     throw new ClassNotFoundException(name, x);
                 }
-                byte[] data = PatchByteCode.patch(baos.toByteArray());
+                byte[] data;
+                try {
+                    Enumeration<URL> res = getResources("META-INF/.bytecodePatched"); // NOI18N
+                    data = PatchByteCode.fromStream(res, this).apply(name, baos.toByteArray());
+                } catch (IOException x) {
+                    throw new ClassNotFoundException(name, x);
+                }
                 Class c = defineClass(name, data, 0, data.length);
                 if (resolve) {
                     resolveClass(c);
diff --git a/openide.modules/apichanges.xml b/openide.modules/apichanges.xml
--- a/openide.modules/apichanges.xml
+++ b/openide.modules/apichanges.xml
@@ -50,6 +50,52 @@
   	<apidef name="modules">Modules API</apidef>
   </apidefs>
 <changes>
+    <change id="PatchSuper">
+        <api name="modules"/>
+        <summary>Support for binary compatibility patches</summary>
+        <version major="7" minor="44"/>
+        <date day="11" month="4" year="2014"/>
+        <author login="sdedic"/>
+        <compatibility addition="yes" binary="compatible" semantic="compatible" source="compatible"/>
+        <description>
+            <p>
+                When removing @deprecated code from API, it is still desirable to retain
+                backward binary compatibility. Because of JVM method/field/class resolution
+                mechanism, it is permitted to move the implementation upwards the inheritance
+                hierarchy. However, the superclass that receives the methods must
+                not be visible in the sources (otherwise the change would not serve any good) and
+                specifically, must not be referenced from `extends' clause of the changed class.
+            </p>
+            <p>
+                The compatibility superclass ought to reside in a completely different module to
+                allow reduce type dependencies and should be only injected into inheritance chain
+                if and only if some of enabled modules depend on the obsolete version of the API module.
+            </p>
+            <p>
+                Special annotation <a href="@TOP@/org/netbeans/modules/PatchFor.html"><code>@PatchFor</code></a>
+                allows to require that a class should serve as a <i>superclass</i> of some other class.
+                See <a href="@TOP@/org/netbeans/modules/PatchFor.html">@PatchFor javadoc</a> for further 
+                constraints.
+            </p>
+            <p>
+                The constructor cannot be 'just moved', because of it contains instance variable initialization
+                code. To support removing obsolete constructors, 
+                <a href="@TOP@/org/netbeans/modules/ConstructorDelegate.html"><code>@ConstructorDelegate</code></a> has been
+                created to mark moved initialization code. See <a href="@TOP@/org/netbeans/modules/ConstructorDelegate.html">@ConstructorDelegate javadoc</a>
+                for more details.
+            </p>
+            <p>
+                The module which contains such patches must share the classloader with the patched one,
+                since classes in those two modules reference each other. A new Manifest entry, <strong>
+                    <code>OpenIDE-Module-Fragment-Host</code>
+                </strong>, is defined. It's value must be set to <strong>codename</strong> of the
+                patched module.
+            </p>
+        </description>
+        <class package="org.netbeans.modules" name="PatchFor"/>
+        <class package="org.netbeans.modules" name="ConstructorDelegate"/>
+        <issue number="243561"/>
+    </change>
     <change id="javafx.lib">
         <api name="modules"/>
         <summary>JavaFX Library Wrapper</summary>
diff --git a/openide.modules/arch.xml b/openide.modules/arch.xml
--- a/openide.modules/arch.xml
+++ b/openide.modules/arch.xml
@@ -82,6 +82,23 @@
     everyone who wishes to learn more about the NetBeans runtime container
     behaviour.
   </usecase>
+  <usecase id="patchfor" name="Runtime compatibility patches">
+      <p>
+        To maintain binary compatibility, method implementations may be injected
+        at runtime, in a form of a superclass in the class' inheritance hierarchy.
+        Modules compiled against older version of APIs which contains MethodReferences to 
+        methods removed from the oficial APIs will be then linked according to JVM Resolution
+        algorithm to a matching method present in the superclass of the referenced type.
+      </p>
+      <p>
+        Annotations are used to instruct the ClassLoader to make transformations to the API
+          classes. <a href="@TOP@/org/netbeans/modules/PatchFor.html">PatchFor</a> causes the annotated
+          class to be injected as a superclass of the API class identified by the annotation's value.
+          <a href="@TOP@/org/netbeans/modules/ConstructorDelegate.html">ConstructorDelegate</a> marks
+          a method, which is called as constructor implementation in the case that it is necessary
+          to preserve a constructor for binary compatibility.
+      </p>
+  </usecase>
 </answer>
 
 
diff --git a/openide.modules/manifest.mf b/openide.modules/manifest.mf
--- a/openide.modules/manifest.mf
+++ b/openide.modules/manifest.mf
@@ -1,5 +1,5 @@
 Manifest-Version: 1.0
 OpenIDE-Module: org.openide.modules
 OpenIDE-Module-Localizing-Bundle: org/openide/modules/Bundle.properties
-OpenIDE-Module-Specification-Version: 7.43
+OpenIDE-Module-Specification-Version: 7.44
 
diff --git a/openide.modules/nbproject/project.properties b/openide.modules/nbproject/project.properties
--- a/openide.modules/nbproject/project.properties
+++ b/openide.modules/nbproject/project.properties
@@ -41,7 +41,7 @@
 # made subject to such option by the copyright holder.
 
 javac.compilerargs=-Xlint -Xlint:-serial
-javac.source=1.6
+javac.source=1.7
 module.jar.dir=lib
 javadoc.main.page=org/openide/modules/doc-files/api.html
 javadoc.arch=${basedir}/arch.xml
diff --git a/openide.modules/src/org/netbeans/modules/openide/modules/PatchedPublicProcessor.java b/openide.modules/src/org/netbeans/modules/openide/modules/PatchedPublicProcessor.java
--- a/openide.modules/src/org/netbeans/modules/openide/modules/PatchedPublicProcessor.java
+++ b/openide.modules/src/org/netbeans/modules/openide/modules/PatchedPublicProcessor.java
@@ -42,10 +42,16 @@
 
 package org.netbeans.modules.openide.modules;
 
+import java.io.BufferedWriter;
 import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
 import java.util.ArrayList;
-import java.util.Collections;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import javax.annotation.processing.AbstractProcessor;
 import javax.annotation.processing.ProcessingEnvironment;
@@ -53,45 +59,103 @@
 import javax.annotation.processing.RoundEnvironment;
 import javax.annotation.processing.SupportedSourceVersion;
 import javax.lang.model.SourceVersion;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
 import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.Modifier;
 import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
 import javax.tools.Diagnostic.Kind;
 import javax.tools.StandardLocation;
+import org.openide.modules.ConstructorDelegate;
+import org.openide.modules.PatchFor;
 import org.openide.modules.PatchedPublic;
 import org.openide.util.lookup.ServiceProvider;
 
 @ServiceProvider(service=Processor.class)
 @SupportedSourceVersion(SourceVersion.RELEASE_6)
 public class PatchedPublicProcessor extends AbstractProcessor {
+    
+    private static final Set<String> ANNOTATIONS = new HashSet<String>(
+        Arrays.asList(
+            PatchedPublic.class.getCanonicalName(),
+            PatchFor.class.getCanonicalName(),
+            ConstructorDelegate.class.getCanonicalName()
+        )
+    );
 
     public @Override Set<String> getSupportedAnnotationTypes() {
-        return Collections.singleton(PatchedPublic.class.getCanonicalName());
+        return ANNOTATIONS;
     }
 
     private List<Element> originatingElements;
-
+    
+    /**
+     * Map keyed by the original API class, values are superclasses to be injected
+     * into the API class.
+     */
+    private Map<String, String>     superclasses = new HashMap<String, String>();
+    
     @Override
     public synchronized void init(ProcessingEnvironment processingEnv) {
         super.init(processingEnv);
         originatingElements = new ArrayList<Element>();
     }
+    
+    private void flush(RoundEnvironment roundEnv) {
+        if (!originatingElements.isEmpty()) {
+            try (OutputStream os = processingEnv.getFiler().createResource(
+                    StandardLocation.CLASS_OUTPUT,
+                    "", "META-INF/.bytecodePatched",
+                    originatingElements.toArray(new Element[originatingElements.size()])).openOutputStream()) {
+                BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os, "UTF-8"));
+                for (Map.Entry<String, String> exEntry : superclasses.entrySet()) {
+                    String api = exEntry.getKey();
+                    String sup = exEntry.getValue();
+                    
+                    bw.append("extend.").append(api).append("=").append(sup);
+                    bw.newLine();
+                }
+                bw.flush();
+            } catch (IOException x) {
+                processingEnv.getMessager().printMessage(Kind.ERROR, x.getMessage());
+            }
+        }
+    }
+    
+    private TypeElement implForElement;
+    private Element valueElement;
+    private boolean reported;
+    
+    private TypeElement getImplFor() {
+        implForElement = processingEnv.getElementUtils().getTypeElement(IMPL_FOR_NAME);
+        if (implForElement == null) {
+            if (!reported) {
+                processingEnv.getMessager().printMessage(Kind.ERROR, "Cannot find @ImplementationFor annotation");
+                reported = true;
+            }
+            return null;
+        }
+        for (Element e : implForElement.getEnclosedElements()) {
+            if (e.getKind() == ElementKind.METHOD && e.getSimpleName().contentEquals("value")) {
+                valueElement = e;
+                break;
+            }
+        }
+        return implForElement;
+    }
+    
+    private static final String IMPL_FOR_NAME = PatchFor.class.getName();
 
     public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
         if (roundEnv.processingOver()) {
-            if (!originatingElements.isEmpty()) {
-                try {
-                    processingEnv.getFiler().createResource(
-                            StandardLocation.CLASS_OUTPUT,
-                            "", "META-INF/.bytecodePatched",
-                            originatingElements.toArray(new Element[originatingElements.size()])).
-                            openOutputStream().close();
-                } catch (IOException x) {
-                    processingEnv.getMessager().printMessage(Kind.ERROR, x.getMessage());
-                }
-            }
+            flush(roundEnv);
             return false;
         }
+        
         for (Element e : roundEnv.getElementsAnnotatedWith(PatchedPublic.class)) {
             if (e.getAnnotationMirrors().size() > 1) {
                 processingEnv.getMessager().printMessage(Kind.ERROR, "Cannot currently mix @PatchedPublic with other annotations", e);
@@ -103,6 +167,68 @@
             }
             originatingElements.add(e);
         }
+        
+        CLAZZ: for (Element e : roundEnv.getElementsAnnotatedWith(PatchFor.class)) {
+            List<? extends AnnotationMirror> mirrors = e.getAnnotationMirrors();
+            String apiName = null;
+            TypeElement target = null;
+            
+            for (AnnotationMirror m : mirrors) {
+                Element me = m.getAnnotationType().asElement();
+                if (me != getImplFor()) {
+                    continue;
+                }
+                AnnotationValue val = m.getElementValues().get(valueElement);
+                if (!(val.getValue() instanceof DeclaredType)) {
+                    processingEnv.getMessager().printMessage(Kind.ERROR, "Value for @ImplementationFor must be a valid class", e);
+                    continue CLAZZ;
+                }
+                Element x = ((DeclaredType)val.getValue()).asElement();
+                if (!(x instanceof TypeElement)) {
+                    processingEnv.getMessager().printMessage(Kind.ERROR, "Value for @ImplementationFor must be a valid class", e);
+                    continue CLAZZ;
+                }
+                target = (TypeElement)x;
+                if (target.getKind() != ElementKind.CLASS) {
+                    processingEnv.getMessager().printMessage(Kind.ERROR, "@ImplementationFor can be only applied on classes", e);
+                    continue CLAZZ;
+                }
+                apiName = processingEnv.getElementUtils().getBinaryName(target).toString();
+                break;
+            }
+            if (target == null) {
+                throw new IllegalStateException();
+            }
+            TypeElement t = (TypeElement)e;
+            
+            boolean defaultCtorFound = false;
+            for (Element el : target.getEnclosedElements()) {
+                if (el.getKind() != ElementKind.CONSTRUCTOR) {
+                    continue;
+                }
+                if (((ExecutableElement)el).getParameters().isEmpty()) {
+                    defaultCtorFound = true;
+                    break;
+                }
+            }
+            if (!defaultCtorFound) {
+                processingEnv.getMessager().printMessage(Kind.ERROR, "Class " + t.getQualifiedName().toString() + " has no default constructor", e);
+                continue CLAZZ;
+            }
+            String superName = processingEnv.getElementUtils().getBinaryName(t).toString();
+            
+            TypeMirror patchSuperClass = t.getSuperclass();
+            TypeMirror targetSuperClass = target.getSuperclass();
+            
+            if (!processingEnv.getTypeUtils().isSameType(patchSuperClass, targetSuperClass)) {
+                processingEnv.getMessager().printMessage(Kind.ERROR, "API class and the substitue differ in their superclasses", e);
+                continue CLAZZ;
+            }
+            superclasses.put(apiName, superName);
+            processingEnv.getMessager().printMessage(Kind.NOTE, "Adding injection of " + superName + " as a superclass of API " + apiName);
+            
+            originatingElements.add(e);
+        }
         return true;
     }
 
diff --git a/openide.modules/src/org/openide/modules/ConstructorDelegate.java b/openide.modules/src/org/openide/modules/ConstructorDelegate.java
new file mode 100644
--- /dev/null
+++ b/openide.modules/src/org/openide/modules/ConstructorDelegate.java
@@ -0,0 +1,69 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright 2014 Oracle and/or its affiliates. All rights reserved.
+ *
+ * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
+ * Other names may be trademarks of their respective owners.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common
+ * Development and Distribution License("CDDL") (collectively, the
+ * "License"). You may not use this file except in compliance with the
+ * License. You can obtain a copy of the License at
+ * http://www.netbeans.org/cddl-gplv2.html
+ * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
+ * specific language governing permissions and limitations under the
+ * License.  When distributing the software, include this License Header
+ * Notice in each file and include the License file at
+ * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the GPL Version 2 section of the License file that
+ * accompanied this code. If applicable, add the following below the
+ * License Header, with the fields enclosed by brackets [] replaced by
+ * your own identifying information:
+ * "Portions Copyrighted [year] [name of copyright owner]"
+ *
+ * If you wish your version of this file to be governed by only the CDDL
+ * or only the GPL Version 2, indicate your decision by adding
+ * "[Contributor] elects to include this software in this distribution
+ * under the [CDDL or GPL Version 2] license." If you do not indicate a
+ * single choice of license, a recipient has the option to distribute
+ * your version of this file under either the CDDL, the GPL Version 2 or
+ * to extend the choice of license to its licensees as provided above.
+ * However, if you add GPL Version 2 code and therefore, elected the GPL
+ * Version 2 license, then the option applies only if the new code is
+ * made subject to such option by the copyright holder.
+ *
+ * Contributor(s):
+ *
+ * Portions Copyrighted 2014 Sun Microsystems, Inc.
+ */
+
+package org.openide.modules;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a code that implements constructor contract for backward compatibility.
+ * There are two possible uses for this annotation. A static void method can be annotated.
+ * The method must take the compat implementation type as its first parameter. The rest
+ * of parameters will be used to generate a constructor in the original API class, 
+ * with the same thrown exceptions and access modifiers. The generated constructor will first call
+ * <b>the default constructor</b> of the API class, then delegate the initialization work
+ * to the static method passing <code>this</code> as the first parameter.
+ * <p/>
+ * The annotation has only effect if the method's declaring class was annotated using
+ * {@link PatchFor}.
+ * 
+ * @see PatchFor
+ * @since 7.44
+ * @author sdedic
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.METHOD})
+public @interface ConstructorDelegate {
+}
diff --git a/openide.modules/src/org/openide/modules/PatchFor.java b/openide.modules/src/org/openide/modules/PatchFor.java
new file mode 100644
--- /dev/null
+++ b/openide.modules/src/org/openide/modules/PatchFor.java
@@ -0,0 +1,82 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright 2014 Oracle and/or its affiliates. All rights reserved.
+ *
+ * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
+ * Other names may be trademarks of their respective owners.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common
+ * Development and Distribution License("CDDL") (collectively, the
+ * "License"). You may not use this file except in compliance with the
+ * License. You can obtain a copy of the License at
+ * http://www.netbeans.org/cddl-gplv2.html
+ * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
+ * specific language governing permissions and limitations under the
+ * License.  When distributing the software, include this License Header
+ * Notice in each file and include the License file at
+ * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the GPL Version 2 section of the License file that
+ * accompanied this code. If applicable, add the following below the
+ * License Header, with the fields enclosed by brackets [] replaced by
+ * your own identifying information:
+ * "Portions Copyrighted [year] [name of copyright owner]"
+ *
+ * If you wish your version of this file to be governed by only the CDDL
+ * or only the GPL Version 2, indicate your decision by adding
+ * "[Contributor] elects to include this software in this distribution
+ * under the [CDDL or GPL Version 2] license." If you do not indicate a
+ * single choice of license, a recipient has the option to distribute
+ * your version of this file under either the CDDL, the GPL Version 2 or
+ * to extend the choice of license to its licensees as provided above.
+ * However, if you add GPL Version 2 code and therefore, elected the GPL
+ * Version 2 license, then the option applies only if the new code is
+ * made subject to such option by the copyright holder.
+ *
+ * Contributor(s):
+ *
+ * Portions Copyrighted 2014 Sun Microsystems, Inc.
+ */
+
+package org.openide.modules;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a class, which provides binary-compatible implementation for a changed API class.
+ * The marked class will be used as a <b>superclass</b> of the API class identified
+ * by value of the annotation, so old clients can still use removed members at run time.
+ * <p/>
+ * The substitute superclass must extend the same type as the original
+ * API class, so that API-visible inheritance chain is preserved. It must declare
+ * all non-private constructors as the original superclass.
+ * <p/>
+ * The module that contains {@code PatchFor} classes <b>must be</b> defined as
+ * module fragment: put
+ * <code><pre>
+ * OpenIDE-Module-Fragment-Host: codenamebase
+ * </pre></code>
+ * into the Module's manifest. The `codenamebase' must identify the host module
+ * which contains the class(es) to be patched.
+ * 
+ * @since 7.44
+ * @author sdedic
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.TYPE})
+public @interface PatchFor {
+    /**
+     * The manifest header name.
+     */
+    public static final String MANIFEST_FRAGMENT_HOST = "OpenIDE-Module-Fragment-Host";
+    
+    /**
+     * @return Class that should be changed to extend the annotated class
+     */
+    public Class<?> value();
+}