diff --git a/CHANGES.md b/CHANGES.md
index 3dba53aa70..6b0f0531e5 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -9,6 +9,7 @@ Features
 --------
 * [#757](https://github.com/java-native-access/jna/issues/757): Build android archive (AAR) - [@matthiasblaesing](https://github.com/matthiasblaesing).
 * [#767](https://github.com/java-native-access/jna/pull/767): Add Win32 API mapping for Shlwapi PathIsUNC - [@ivanwick](https://github.com/ivanwick).
+* [#753](https://github.com/java-native-access/jna/issues/753): Support arm hardfloat and softfloat by introducing armel as platform (ARM EABI Little-endian) - [@matthiasblaesing](https://github.com/matthiasblaesing).
 
 Bug Fixes
 ---------
diff --git a/ant-elfanalyser-src/com/sun/jna/BuildArmSoftFloatDetector.java b/ant-elfanalyser-src/com/sun/jna/BuildArmSoftFloatDetector.java
new file mode 100644
index 0000000000..fe43f9543e
--- /dev/null
+++ b/ant-elfanalyser-src/com/sun/jna/BuildArmSoftFloatDetector.java
@@ -0,0 +1,53 @@
+
+package com.sun.jna;
+
+import java.io.File;
+import java.io.IOException;
+import org.apache.tools.ant.Project;
+
+/**
+ * Ant task to expose the arm soft-/hardfloat detection routines of the JNA core
+ * for the build script.
+ * 
+ * <p>The build script is expected to build a minimal set of classes that are 
+ * required to execute this. At the time of writing these are:</p>
+ * 
+ * <ul>
+ * <li>com.sun.jna.ELFAnalyser</li>
+ * </ul>
+ */
+public class BuildArmSoftFloatDetector {
+
+    private String targetProperty;
+    private Project project;
+
+    public void setProject(Project proj) {
+        project = proj;
+    }
+
+    /**
+     * targetProperty receives the name of the property, that should take the
+     * new property
+     * 
+     * @param targetProperty 
+     */
+    public void setTargetProperty(String targetProperty) {
+        this.targetProperty = targetProperty;
+    }
+    
+    public void execute() throws IOException {
+        boolean result = false;
+        // On linux /proc/self/exe is a symblink to the currently executing
+        // binary (the JVM)
+        File self = new File("/proc/self/exe");
+        try {
+            // The self.getCanonicalPath() resolves the symblink to the backing
+            // realfile and passes that to the detection routines
+            ELFAnalyser ahfd = ELFAnalyser.analyse(self.getCanonicalPath());
+            result = ahfd.isArmSoftFloat();
+        } catch (IOException ex) {
+            result = false;
+        }
+        project.setNewProperty(targetProperty, Boolean.toString(result));
+    }
+}
diff --git a/build.xml b/build.xml
index b024b2060f..b2c67b6ce7 100644
--- a/build.xml
+++ b/build.xml
@@ -208,6 +208,17 @@
     <property name="test.classes" location="${build}/test-classes"/>
     <property name="reports" value="${build}/reports"/>
 
+    <mkdir dir="${build}/ant-elfanalyser" />
+    <javac classpath="lib/ant.jar" destdir="${build}/ant-elfanalyser" includeantruntime="false">
+        <src path="src" />
+        <src path="ant-elfanalyser-src" />
+        <include name="**/ELFAnalyser.java" />
+        <include name="**/BuildArmSoftFloatDetector.java" />
+    </javac>
+
+    <taskdef name="BuildArmSoftFloatDetector" classname="com.sun.jna.BuildArmSoftFloatDetector" classpath="${build}/ant-elfanalyser" />
+    <BuildArmSoftFloatDetector targetProperty="build.isArmSoftFloat"/>
+    
     <!-- Add other supported platforms here -->
     <condition property="jre.arch" value="x86">
       <matches pattern="(i[3456]86|pentium)" string="${os.arch}"/>
@@ -230,7 +241,15 @@
     <condition property="jre.arch" value="ppc64">
       <matches pattern="(powerpc64|power64)" string="${os.arch}"/>
     </condition>
+    <condition property="jre.arch" value="armel">
+      <and>
+        <matches pattern="arm" string="${os.arch}"/>
+        <matches pattern="true" string="${build.isArmSoftFloat}"/>
+      </and>
+    </condition>
+    
     <property name="jre.arch" value="${os.arch}"/>
+    
     <condition property="os.prefix" value="linux-${jre.arch}">
       <os name="Linux"/>
     </condition>
@@ -424,6 +443,8 @@ com/sun/jna/linux-x86-64/libjnidispatch.so;
 processor=x86-64;osname=linux,
 com/sun/jna/linux-arm/libjnidispatch.so;
 processor=arm;osname=linux,
+com/sun/jna/linux-armel/libjnidispatch.so;
+processor=armel;osname=linux,
 com/sun/jna/linux-aarch64/libjnidispatch.so;
 processor=aarch64;osname=linux,
 com/sun/jna/linux-ia64/libjnidispatch.so;
@@ -468,6 +489,9 @@ osname=macosx;processor=x86;processor=x86-64;processor=ppc
       <zipfileset src="${lib.native}/linux-arm.jar"
                   includes="*jnidispatch*"
                   prefix="com/sun/jna/linux-arm"/>
+      <zipfileset src="${lib.native}/linux-armel.jar"
+                  includes="*jnidispatch*"
+                  prefix="com/sun/jna/linux-armel"/>
       <zipfileset src="${lib.native}/linux-aarch64.jar"
                   includes="*jnidispatch*"
                   prefix="com/sun/jna/linux-aarch64"/>
@@ -666,6 +690,7 @@ osname=macosx;processor=x86;processor=x86-64;processor=ppc
     <copy file="${lib.native}/out-of-date.jar" tofile="${lib.native}/linux-x86.jar" overwrite="true"/>
     <copy file="${lib.native}/out-of-date.jar" tofile="${lib.native}/linux-x86-64.jar" overwrite="true"/>
     <copy file="${lib.native}/out-of-date.jar" tofile="${lib.native}/linux-arm.jar" overwrite="true"/>
+    <copy file="${lib.native}/out-of-date.jar" tofile="${lib.native}/linux-armel.jar" overwrite="true"/>
     <copy file="${lib.native}/out-of-date.jar" tofile="${lib.native}/linux-aarch64.jar" overwrite="true"/>
     <copy file="${lib.native}/out-of-date.jar" tofile="${lib.native}/linux-ia64.jar" overwrite="true"/>
     <copy file="${lib.native}/out-of-date.jar" tofile="${lib.native}/linux-ppc.jar" overwrite="true"/>
@@ -1318,6 +1343,4 @@ osname=macosx;processor=x86;processor=x86-64;processor=ppc
       <arg value="-Dgpg.useagent=true"/>
     </artifact:mvn>
   </target>
-</project>
-
-
+</project>
\ No newline at end of file
diff --git a/lib/ant.jar b/lib/ant.jar
new file mode 100644
index 0000000000..3bebb5c883
Binary files /dev/null and b/lib/ant.jar differ
diff --git a/lib/native/linux-armel.jar b/lib/native/linux-armel.jar
new file mode 100644
index 0000000000..1319f4edf5
Binary files /dev/null and b/lib/native/linux-armel.jar differ
diff --git a/nbproject/project.xml b/nbproject/project.xml
index 4f75977b70..6a29d18789 100644
--- a/nbproject/project.xml
+++ b/nbproject/project.xml
@@ -3,6 +3,9 @@
     <type>org.netbeans.modules.ant.freeform</type>
     <configuration>
         <general-data xmlns="http://www.netbeans.org/ns/freeform-project/1">
+            <name>JNA</name>
+        </general-data>
+        <general-data xmlns="http://www.netbeans.org/ns/freeform-project/2">
             <!-- Do not use Project Properties customizer when editing this file manually. 
  To prevent the customizer from showing, create nbproject/project.properties file and enter 
 auxiliary.show.customizer=false 
@@ -12,15 +15,28 @@ auxiliary.show.customizer.message=<message>
             <name>JNA</name>
             <properties/>
             <folders>
+                <source-folder>
+                    <label>JNA</label>
+                    <location>.</location>
+                    <encoding>UTF-8</encoding>
+                </source-folder>
                 <source-folder>
                     <label>src</label>
                     <type>java</type>
                     <location>src</location>
+                    <encoding>UTF-8</encoding>
                 </source-folder>
                 <source-folder>
                     <label>test</label>
                     <type>java</type>
                     <location>test</location>
+                    <encoding>UTF-8</encoding>
+                </source-folder>
+                <source-folder>
+                    <label>ant-elfanalyser-src</label>
+                    <type>java</type>
+                    <location>ant-elfanalyser-src</location>
+                    <encoding>UTF-8</encoding>
                 </source-folder>
             </folders>
             <ide-actions>
@@ -51,6 +67,10 @@ auxiliary.show.customizer.message=<message>
                         <label>test</label>
                         <location>test</location>
                     </source-folder>
+                    <source-folder style="packages">
+                        <label>ant-elfanalyser-src</label>
+                        <location>ant-elfanalyser-src</location>
+                    </source-folder>
                     <source-file>
                         <location>build.xml</location>
                     </source-file>
@@ -63,15 +83,23 @@ auxiliary.show.customizer.message=<message>
                     <ide-action name="test"/>
                 </context-menu>
             </view>
+            <subprojects/>
         </general-data>
         <java-data xmlns="http://www.netbeans.org/ns/freeform-project-java/2">
             <compilation-unit>
                 <package-root>src</package-root>
+                <classpath mode="compile">src</classpath>
                 <source-level>1.5</source-level>
             </compilation-unit>
             <compilation-unit>
                 <package-root>test</package-root>
                 <unit-tests/>
+                <classpath mode="compile">lib/hamcrest-core-1.3.jar:lib/junit.jar:lib/test/dom4j-1.6.1.jar:lib/test/guava-11.0.2.jar:lib/test/javassist-3.12.1.GA.jar:lib/test/reflections-0.9.8.jar:lib/test/slf4j-api-1.6.1.jar:src</classpath>
+                <source-level>1.5</source-level>
+            </compilation-unit>
+            <compilation-unit>
+                <package-root>ant-elfanalyser-src</package-root>
+                <classpath mode="compile">src:lib/ant.jar</classpath>
                 <source-level>1.5</source-level>
             </compilation-unit>
         </java-data>
diff --git a/src/com/sun/jna/ELFAnalyser.java b/src/com/sun/jna/ELFAnalyser.java
new file mode 100644
index 0000000000..c3eed7985f
--- /dev/null
+++ b/src/com/sun/jna/ELFAnalyser.java
@@ -0,0 +1,140 @@
+
+package com.sun.jna;
+
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Arrays;
+
+/**
+ * Analyse an ELF file for platform specific attributes.
+ * 
+ * <p>Primary use-case: Detect whether the java binary is arm hardfloat or softfloat.</p>
+ */
+class ELFAnalyser {
+    /**
+     * Generic ELF header
+     */
+    private static final byte[] ELF_MAGIC = new byte[]{(byte) 0x7F, (byte) 'E', (byte) 'L', (byte) 'F'};
+    /**
+     * e_flags mask if executable file conforms to hardware floating-point
+     * procedure-call standard (arm ABI version 5)
+     */
+    private static final int EF_ARM_ABI_FLOAT_HARD = 0x00000400;
+    /**
+     * e_flags mask if executable file conforms to software floating-point
+     * procedure-call standard (arm ABI version 5)
+     */
+    private static final int EF_ARM_ABI_FLOAT_SOFT = 0x00000200;
+    private static final int EI_DATA_BIG_ENDIAN = 2;
+    private static final int E_MACHINE_ARM = 0x28;
+    private static final int EI_CLASS_64BIT = 2;
+    
+    public static ELFAnalyser analyse(String filename) throws IOException {
+        ELFAnalyser res = new ELFAnalyser(filename);
+        res.runDetection();
+        return res;
+    }
+    
+    private final String filename;
+    private boolean ELF = false;
+    private boolean _64Bit = false;
+    private boolean bigEndian = false;
+    private boolean armHardFloat = false;
+    private boolean armSoftFloat = false;
+    private boolean arm = false;
+
+    /**
+     * @return true if the parsed file was detected to be an ELF file
+     */
+    public boolean isELF() {
+        return ELF;
+    }
+
+    /**
+     * @return true if the parsed file was detected to be for a 64bit architecture
+     * and pointers are expected to be 8byte wide
+     */
+    public boolean is64Bit() {
+        return _64Bit;
+    }
+
+    /**
+     * @return true if the parsed file is detected to be big endian, false if 
+     * the file is little endian
+     */
+    public boolean isBigEndian() {
+        return bigEndian;
+    }
+
+    /**
+     * @return filename of the parsed file
+     */
+    public String getFilename() {
+        return filename;
+    }
+
+    /**
+     * @return true if file was detected to conform to the hardware floating-point
+     * procedure-call standard
+     */
+    public boolean isArmHardFloat() {
+        return armHardFloat;
+    }
+
+    /**
+     * @return true if file was detected to conform to the software floating-point
+     * procedure-call standard
+     */
+    public boolean isArmSoftFloat() {
+        return armSoftFloat;
+    }
+
+    /**
+     * @return true if the parsed file was detected to be build for the arm
+     * architecture
+     */
+    public boolean isArm() {
+        return arm;
+    }
+
+    private ELFAnalyser(String filename) {
+        this.filename = filename;
+    }
+
+    private void runDetection() throws IOException {
+        // run precheck - only of if the file at least hold an ELF header parsing
+        // runs further.
+        RandomAccessFile raf = new RandomAccessFile(filename, "r");
+        if (raf.length() > 4) {
+            byte[] magic = new byte[4];
+            raf.seek(0);
+            raf.read(magic);
+            if (Arrays.equals(magic, ELF_MAGIC)) {
+                ELF = true;
+            }
+        }
+        if (!ELF) {
+            return;
+        }
+        raf.seek(4);
+        // The total header size depends on the pointer size of the platform
+        // so before the header is loaded the pointer size has to be determined
+        byte sizeIndicator = raf.readByte();
+        _64Bit = sizeIndicator == EI_CLASS_64BIT;
+        raf.seek(0);
+        ByteBuffer headerData = ByteBuffer.allocate(_64Bit ? 64 : 52);
+        raf.getChannel().read(headerData, 0);
+        bigEndian = headerData.get(5) == EI_DATA_BIG_ENDIAN;
+        headerData.order(bigEndian ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN);
+
+        arm = headerData.get(0x12) == E_MACHINE_ARM;
+        
+        if(arm) {
+            int flags = headerData.getInt(_64Bit ? 0x30 : 0x24);
+            armSoftFloat = (flags & EF_ARM_ABI_FLOAT_SOFT) == EF_ARM_ABI_FLOAT_SOFT;
+            armHardFloat = (flags & EF_ARM_ABI_FLOAT_HARD) == EF_ARM_ABI_FLOAT_HARD;
+        }
+    }
+}
diff --git a/src/com/sun/jna/Platform.java b/src/com/sun/jna/Platform.java
index 5a50c33b0d..8cc702247a 100644
--- a/src/com/sun/jna/Platform.java
+++ b/src/com/sun/jna/Platform.java
@@ -22,6 +22,11 @@
  */
 package com.sun.jna;
 
+import java.io.File;
+import java.io.IOException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
 /** Provide simplified platform information. */
 public final class Platform {
     public static final int UNSPECIFIED = -1;
@@ -125,7 +130,7 @@ else if (osName.equalsIgnoreCase("netbsd")) {
         C_LIBRARY_NAME = osType == WINDOWS ? "msvcrt" : osType == WINDOWSCE ? "coredll" : "c";
         MATH_LIBRARY_NAME = osType == WINDOWS ? "msvcrt" : osType == WINDOWSCE ? "coredll" : "m";
         HAS_DLL_CALLBACKS = osType == WINDOWS;
-	ARCH = getCanonicalArchitecture(System.getProperty("os.arch"));
+	ARCH = getCanonicalArchitecture(System.getProperty("os.arch"), isSoftFloat());
         RESOURCE_PREFIX = getNativeLibraryResourcePrefix();
     }
     private Platform() { }
@@ -220,7 +225,7 @@ public static final boolean isSPARC() {
         return ARCH.startsWith("sparc");
     }
 
-    static String getCanonicalArchitecture(String arch) {
+    static String getCanonicalArchitecture(String arch, boolean softfloat) {
 	arch = arch.toLowerCase().trim();
         if ("powerpc".equals(arch)) {
             arch = "ppc";
@@ -239,14 +244,37 @@ else if ("x86_64".equals(arch) || "amd64".equals(arch)) {
 	if ("ppc64".equals(arch) && "little".equals(System.getProperty("sun.cpu.endian"))) {
 	    arch = "ppc64le";
 	}
+        // Map arm to armel if the binary is running as softfloat build
+        if("arm".equals(arch) && softfloat) {
+            arch = "armel";
+        }
+        
+        
 	return arch;
     }
+    
+    private static boolean isSoftFloat() {
+        try {
+            File self = new File("/proc/self/exe");
+            ELFAnalyser ahfd = ELFAnalyser.analyse(self.getCanonicalPath());
+            return ahfd.isArmSoftFloat();
+        } catch (IOException ex) {
+            // asume hardfloat
+            Logger.getLogger(Platform.class.getName()).log(Level.FINE, null, ex);
+        }
+        return false;
+    }
 
     /** Generate a canonical String prefix based on the current OS 
         type/arch/name.
     */
     static String getNativeLibraryResourcePrefix() {
-        return getNativeLibraryResourcePrefix(getOSType(), System.getProperty("os.arch"), System.getProperty("os.name"));
+        String prefix = System.getProperty("jna.prefix");
+        if(prefix != null) {
+            return prefix;
+        } else {
+            return getNativeLibraryResourcePrefix(getOSType(), System.getProperty("os.arch"), System.getProperty("os.name"));
+        }
     }
 
     /** Generate a canonical String prefix based on the given OS
@@ -256,8 +284,12 @@ static String getNativeLibraryResourcePrefix() {
         @param name from <code>os.name</code> System property
     */
     static String getNativeLibraryResourcePrefix(int osType, String arch, String name) {
+        return getNativeLibraryResourcePrefix(osType, arch, name, isSoftFloat());
+    }
+    
+    static String getNativeLibraryResourcePrefix(int osType, String arch, String name, boolean isSoftfloat) {
         String osPrefix;
-        arch = getCanonicalArchitecture(arch);
+        arch = getCanonicalArchitecture(arch, isSoftfloat);
         switch(osType) {
         case Platform.ANDROID:
             if (arch.startsWith("arm")) {
diff --git a/test/com/sun/jna/ELFAnalyserTest.java b/test/com/sun/jna/ELFAnalyserTest.java
new file mode 100644
index 0000000000..bf26e12ca6
--- /dev/null
+++ b/test/com/sun/jna/ELFAnalyserTest.java
@@ -0,0 +1,108 @@
+
+package com.sun.jna;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+import org.junit.AfterClass;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+
+public class ELFAnalyserTest {
+
+    
+    private static File testResources = new File("build/test-resources");
+    private static File win32Lib = new File(testResources, "win32-x86-64.dll");
+    private static File linuxArmelLib = new File(testResources, "linux-armel.so");
+    private static File linuxArmhfLib = new File(testResources, "linux-armhf.so");
+    private static File linuxAmd64Lib = new File(testResources, "linux-amd64.so");
+    
+    @BeforeClass
+    public static void initClass() throws IOException {
+        File win32Zip = new File("lib/native/win32-x86-64.jar");
+        File linuxArmelZip = new File("lib/native/linux-armel.jar");
+        File linuxArmhfZip = new File("lib/native/linux-arm.jar");
+        File linuxAmd64Zip = new File("lib/native/linux-x86-64.jar");
+        
+        testResources.mkdirs();
+        
+        extractFileFromZip(win32Zip, "jnidispatch.dll", win32Lib);
+        extractFileFromZip(linuxArmelZip, "libjnidispatch.so", linuxArmelLib);
+        extractFileFromZip(linuxArmhfZip, "libjnidispatch.so", linuxArmhfLib);
+        extractFileFromZip(linuxAmd64Zip, "libjnidispatch.so", linuxAmd64Lib);
+    }
+    
+    @Test
+    public void testNonELF() throws IOException {
+        ELFAnalyser ahfd = ELFAnalyser.analyse(win32Lib.getAbsolutePath());
+        assertFalse(ahfd.isELF());
+    }
+    
+    @Test
+    public void testNonArm() throws IOException {
+        ELFAnalyser ahfd = ELFAnalyser.analyse(linuxAmd64Lib.getAbsolutePath());
+        assertTrue(ahfd.isELF());
+        assertFalse(ahfd.isArm());
+        assertTrue(ahfd.is64Bit());
+    }
+    
+    @Test
+    public void testArmhf() throws IOException {
+        ELFAnalyser ahfd = ELFAnalyser.analyse(linuxArmhfLib.getAbsolutePath());
+        assertTrue(ahfd.isELF());
+        assertTrue(ahfd.isArm());
+        assertFalse(ahfd.is64Bit());
+        assertFalse(ahfd.isArmSoftFloat());
+        assertTrue(ahfd.isArmHardFloat());
+    }
+    
+    @Test
+    public void testArmel() throws IOException {
+        ELFAnalyser ahfd = ELFAnalyser.analyse(linuxArmelLib.getAbsolutePath());
+        assertTrue(ahfd.isELF());
+        assertTrue(ahfd.isArm());
+        assertFalse(ahfd.is64Bit());
+        assertTrue(ahfd.isArmSoftFloat());
+        assertFalse(ahfd.isArmHardFloat());
+    }
+    
+    @AfterClass
+    public static void afterClass() throws IOException {
+        linuxAmd64Lib.delete();
+        linuxArmhfLib.delete();
+        linuxArmelLib.delete();
+        win32Lib.delete();
+        testResources.delete();
+    }
+    
+    private static void extractFileFromZip(File zipTarget, String zipEntryName, File outputFile) throws IOException {
+        ZipFile zip = new ZipFile(zipTarget);
+        try {
+            ZipEntry entry = zip.getEntry(zipEntryName);
+            if(entry == null)  {
+                throw new IOException("ZipEntry for name " + zipEntryName + " not found in " + zipTarget.getAbsolutePath());
+            }
+            InputStream is = zip.getInputStream(entry); // Implicitly closed by closing ZipFile
+            OutputStream os = new FileOutputStream(outputFile);
+            try {
+                int read;
+                byte[] buffer = new byte[1024 * 1024];
+                while((read = is.read(buffer)) > 0) {
+                    os.write(buffer, 0, read);
+                }
+            } finally {
+                os.close();
+            }
+        } finally {
+            zip.close();
+        }
+    }
+}
+
diff --git a/test/com/sun/jna/PlatformTest.java b/test/com/sun/jna/PlatformTest.java
index 8349885edf..1c11be7506 100644
--- a/test/com/sun/jna/PlatformTest.java
+++ b/test/com/sun/jna/PlatformTest.java
@@ -31,68 +31,83 @@ public class PlatformTest extends TestCase {
     public void testOSPrefix() {
         assertEquals("Wrong resource path", "win32-x86",
                      Platform.getNativeLibraryResourcePrefix(Platform.WINDOWS,
-                                                             "x86", "Windows"));
+                                                             "x86", "Windows", false));
         assertEquals("Wrong resource path Windows/i386", "win32-x86",
                      Platform.getNativeLibraryResourcePrefix(Platform.WINDOWS,
-                                                             "i386", "Windows"));
+                                                             "i386", "Windows", false));
         assertEquals("Wrong resource path Windows CE/arm", "w32ce-arm",
                      Platform.getNativeLibraryResourcePrefix(Platform.WINDOWSCE,
-                                                             "arm", "Windows CE"));
+                                                             "arm", "Windows CE", false));
         assertEquals("Wrong resource path Mac/x86", "darwin",
                      Platform.getNativeLibraryResourcePrefix(Platform.MAC,
-                                                             "x86", "Darwin"));
+                                                             "x86", "Darwin", false));
         assertEquals("Wrong resource path Mac/x86", "darwin",
                      Platform.getNativeLibraryResourcePrefix(Platform.MAC,
-                                                             "i386", "Darwin"));
+                                                             "i386", "Darwin", false));
         assertEquals("Wrong resource path Mac/x86_64", "darwin",
                      Platform.getNativeLibraryResourcePrefix(Platform.MAC,
-                                                             "x86_64", "Mac"));
+                                                             "x86_64", "Mac", false));
         assertEquals("Wrong resource path Solaris/sparc", "sunos-sparc",
                      Platform.getNativeLibraryResourcePrefix(Platform.SOLARIS,
-                                                             "sparc", "Solaris"));
+                                                             "sparc", "Solaris", false));
         assertEquals("Wrong resource path SunOS/sparcv9", "sunos-sparcv9",
                      Platform.getNativeLibraryResourcePrefix(Platform.SOLARIS,
-                                                             "sparcv9", "SunOS"));
+                                                             "sparcv9", "SunOS", false));
         assertEquals("Wrong resource path Linux/i386", "linux-x86",
                      Platform.getNativeLibraryResourcePrefix(Platform.LINUX,
-                                                             "i386", "Linux/Gnu"));
+                                                             "i386", "Linux/Gnu", false));
         assertEquals("Wrong resource path Linux/x86", "linux-x86",
                      Platform.getNativeLibraryResourcePrefix(Platform.LINUX,
-                                                             "x86", "Linux"));
+                                                             "x86", "Linux", false));
         assertEquals("Wrong resource path Linux/x86", "linux-x86-64",
                      Platform.getNativeLibraryResourcePrefix(Platform.LINUX,
-                                                             "x86_64", "Linux"));
+                                                             "x86_64", "Linux", false));
         assertEquals("Wrong resource path Linux/x86", "linux-x86-64",
                      Platform.getNativeLibraryResourcePrefix(Platform.LINUX,
-                                                             "amd64", "Linux"));
+                                                             "amd64", "Linux", false));
         assertEquals("Wrong resource path Linux/ppc", "linux-ppc",
                      Platform.getNativeLibraryResourcePrefix(Platform.LINUX,
-                                                             "powerpc", "Linux"));
+                                                             "powerpc", "Linux", false));
         assertEquals("Wrong resource path Linux/sparcv9", "linux-sparcv9",
                      Platform.getNativeLibraryResourcePrefix(Platform.LINUX,
-                                                             "sparcv9", "Linux"));
+                                                             "sparcv9", "Linux", false));
+        assertEquals("Wrong resource path Linux/arm (hardfloat)", "linux-arm",
+                     Platform.getNativeLibraryResourcePrefix(Platform.LINUX,
+                                                             "arm", "Linux/Gnu", false));
+        assertEquals("Wrong resource path Linux/arm (softfloat)", "linux-armel",
+                     Platform.getNativeLibraryResourcePrefix(Platform.LINUX,
+                                                             "arm", "Linux/Gnu", true));
         assertEquals("Wrong resource path OpenBSD/x86", "openbsd-x86",
                      Platform.getNativeLibraryResourcePrefix(Platform.OPENBSD,
-                                                             "x86", "OpenBSD"));
+                                                             "x86", "OpenBSD", false));
         assertEquals("Wrong resource path FreeBSD/x86", "freebsd-x86",
                      Platform.getNativeLibraryResourcePrefix(Platform.FREEBSD,
-                                                             "x86", "FreeBSD"));
+                                                             "x86", "FreeBSD", false));
         assertEquals("Wrong resource path GNU/kFreeBSD/x86", "kfreebsd-x86",
                      Platform.getNativeLibraryResourcePrefix(Platform.KFREEBSD,
-                                                             "x86", "GNU/kFreeBSD"));
+                                                             "x86", "GNU/kFreeBSD", false));
         assertEquals("Wrong resource path NetBSD/x86", "netbsd-x86",
                      Platform.getNativeLibraryResourcePrefix(Platform.NETBSD,
-                                                             "x86", "NetBSD"));
+                                                             "x86", "NetBSD", false));
         assertEquals("Wrong resource path Linux/armv7l (android)", "android-arm",
                      Platform.getNativeLibraryResourcePrefix(Platform.ANDROID,
-                                                             "armv7l", "Linux"));
+                                                             "armv7l", "Linux", false));
         
         assertEquals("Wrong resource path other/other", "name-ppc",
                      Platform.getNativeLibraryResourcePrefix(Platform.UNSPECIFIED,
-                                                             "PowerPC", "Name Of System"));
+                                                             "PowerPC", "Name Of System", false));
         
     }
 
+    public void testSystemProperty() {
+        String demoOverride = "demoOverride";
+        assertFalse(demoOverride.equals(Platform.getNativeLibraryResourcePrefix()));
+        
+        System.setProperty("jna.prefix", demoOverride);
+        assertTrue(demoOverride.equals(Platform.getNativeLibraryResourcePrefix()));
+        
+        System.clearProperty("jna.prefix");
+    }
 
     public static void main(String[] args) {
         junit.textui.TestRunner.run(PlatformTest.class);
diff --git a/www/FrequentlyAskedQuestions.md b/www/FrequentlyAskedQuestions.md
index 76c64148e1..13e55a6662 100644
--- a/www/FrequentlyAskedQuestions.md
+++ b/www/FrequentlyAskedQuestions.md
@@ -20,7 +20,17 @@ That's all it takes.  If you'd like to submit the change back to JNA, make sure
 Calling `Native.loadLibrary()` causes an UnsatisfiedLinkError
 -------------------------------------------------------------
 
-Set the system property `jna.debug_load=true`, and JNA will print its library search steps to the console.  `jna.debug_load.jna` will trace the search for JNA's own native support.
+Set the system property `jna.debug_load=true`, and JNA will print its library 
+search steps to the console. `jna.debug_load.jna` will trace the search for 
+JNA's own native support.
+
+If the native prefix value is misdetected. It can be overriden by the 
+`jna.prefix` system property. For example if the binary running the JVM follows
+the arm softfloat ABI, you can specify the `armel` prefix like this:
+
+```
+java -Djna.prefix=linux-armel <normalCall>
+```
 
 My library mapping causes an UnsatisfiedLinkError
 -------------------------------------------------