Dpdl is a rapid development programming language and constrained device framework with built-in database technology.
Dpdl enables access to the Java platform JRE API and to external java libraries, Native shared libraries, Wasm modules and GPUs and supports the embedding and on-the-fly execution of multiple programming languages like ANSI C, C++, Python, Julia, JavaScript, Lua, Ruby, Java, Groovy, Wgsl and Clojure directly within Dpdl code.
Further programming languages and natural language interpreters can be implemented as extensions and embedded via a dedicated plug-in interface and configuration (Dpdl language plug-ins).
Dpdl is Self contained, Portable and Highly customizable via a dedicated extensible interface. For example the C++ ROOT Data Analysis framework from Cern is also available as Dpdl language plug-in.
These features make Dpdl a powerful development platform for rapid development and fast prototyping, in particular also due to the fact that software written with Dpdl will be enabled to access thousands of existing high-quality software libraries.
A dedicated Dpdl language plug-in (DpdlAINerd) for AI generative code allows also to automatically generate and embed executable code sections via defined embedded natural language descriptions inside Dpdl code.
Dpdl is not intended to replace, but to enable integration of different technologies seamlessly to leverage research and facilitate development.
Prototype sample applications implemented with Dpdl can be found on this GitHub repository:
Dpdl-sample-Apps
Visit also the official Dpdl-io repository on GitHub for updates:
DpdlEngine
DpdlEngine stack overview
By combining the portability and vast API availability of Java and Python, the computational power of Julia, the web enablement of JavaScript and WebAssembly (Wasm), the expressiveness of Lua and Clojure, the simplicity of Ruby and Groovy, the power of C and C++ programming language and a simple access to java Api’s, Native libraries, Wasm modules and GPUs, Dpdl provides a powerful and versatile development platform for industrial applications, education and research.
Embedded ANSI C code, OCaml, Groovy and Clojure are dynamically compiled in memory at runtime in order to achieve faster execution performance.
This makes Dpdl suitable for a wide range of use-cases and in particular also for Hardware programming.
Common IoT protocol stacks such as Bluetooth™ and CoAP (Constrained Application Protocol) are supported by default and further protocols and functions can be added as extensions.
The included Dpdl language plug-in ‘DpdlAINerd’ (DAN) makes use of AI generative code to enable to automatically generate and embed executable code and content or data by natural language descriptions contained in Dpdl code.
Dpdl can be used as:
Rapid application development platform and Fast prototyping
Embedded scripting engine
Library module
Utility tool
Data handling on memory constrained devices
Development of Domain Specific Languages (DSL)
AI generative code
Dpdl can also be used to encode, store, control and query data efficiently on small memory footprint devices. Dpdl comes with a very compact (ca. 650 Kb for DpdlEngine core + ANSI C interpreter/compiler) and portable scripting engine with an extensible API interface for the development of mobile applications and embedded system software.
The Dpdl language constructs and syntax is kept simple and follows an Object Oriented paradigm interoperable with the Java platform API and external java libraries.
DpdlEngine is optimized to run on a wide range of platforms (J2ME, JavaME, J2SE, any other JVM >= 1.4 Spec, and all platforms where the open source virtual machine ‘miniJVM’ can be compiled for the target platform)
Dpdl scripting API provides access to the complete underlying Java JRE platform API and to external java and Native shared libraries
Multiple embeddable programming language plug-ins available: ANSI C code, C++, Python, Julia, JavaScript, Lua , Ruby, Java, Groovy, Wgsl and Clojure languages can be embedded and executed directly within Dpdl scripts (interpreted/compiled code)
Further programming languages can be embedded via a dedicated plug-in interface
Dpdl Wasm runtime plug-in included allows to compile and access ‘Wasm’ module functions within dpdl and from embedded language code
No additional installations required (except add-on libraries)
Includes embedded C compiler: On-the-fly compilation and execution of embedded ANSI C code (in memory at runtime) -> very Fast compile time
Built-in Dpdl scripting engine with support for custom extensions (DpdlExtension interface) -> allows to dynamically add language features
On the fly conversion/compilation of Dpdl data struct’s into native java bytecode
Support for common IoT protocol stacks such as Bluetooth™ (JSR-82) and CoAP (Constrained Application Protocol) (IETF standard RFC 7252)
Packing data in a ‘DpdlPacket’ is a convenient way to optimize and speedup access to data. The speedup is x 25 times faster compared to a standard record store access
Virtual record store filesystem
Double precision floating point emulation layer
XML with XPath parser
JSON
Easy integration of custom libraries
Fast Prototyping
Small footprint Only ca. 372 Kb
for core DpdlEngine -> can be stripped down to 80 Kb
for minimal setup
Tools for automatically converting Dpdl scripts to Java , C/C++ and V code
Allows to automatically generate and embed generative AI programming code within Dpdl using the ‘DpdlAINerd’ (DAN) Dpdl language plug-in
Allows to scale computations on GPUs using the ‘Wgsl’ dpdl language plug-in (WebGPU shading language)
Open Source language plugins
Dpdl provides API functions to load and access java objects and methods of the underlying JRE platform and of any other external java libraries. This allows to use a broad set of API’s within Dpdl.
This is a sample Dpdl app implementing a 3D model visualization of chemical molecules using the JavaFX library. The model can be rotated freely with mouse events.
graphics/dpdl3DJavaFX_molecule.h
VIDEO of Dpdl sample 3D application
Multiple programming languages can be embedded within the same Dpdl code via the keyword >>
.
Further programming languages or custom syntax interpreters can be developed and integrated in a straight forward way via a dedicated plug-in interface and configuration. This enables basically every sort of programming language or natural language interpreter to be embedded directly in Dpdl code.
This features is very useful for rapid development and rapid prototyping and is also a key feature for generative software.
Currenlty the following programming languages are supported:
available add-on Plug-ins:
Sample Dpdl script with embedded ‘C’ code and javascript:
struct A {
string id = "A"
int x = 10
float f = 0.3
double d = 0.4d
object stro = loadObj("String", "This is a java.lang.String object")
func print()
println("------------------")
println("id: " + id)
end
}
# main
println("With Dpdl you can make use of any java library and embed different programming languages...")
struct A mya
mya.print()
println("creating a hashmap to store key/value pairs...")
object mymap = loadObj("HashMap")
mymap.put(1, "Dpdl")
mymap.put(2, "is")
mymap.put(3, "Simple")
mymap.put(4, "Compact")
mymap.put(5, "Portable")
object keys = mymap.keySet()
object iter = keys.iterator()
object key, value
for(iter.hasNext())
key = iter.next()
value = mymap.get(key)
println("key: " + key + " value: " + value)
endfor
bool bcon = mymap.containsValue("Dpdl")
println("mymap contains 'Dpdl': " + bcon)
println("")
println("Embed different programming languages directly..")
println("")
int n = 6
double x = 10.0d
string a = "test"
println("embedding C...")
dpdl_stack_push("dpdlbuf_var1",n, x, a)
>>c
#include <stdio.h>
#include <dpdl.h>
int dpdl_main(int argc, char **argv){
printf("Hello C from Dpdl!\n");
printf("\n");
printf("num params: %d\n", argc);
int cnt;
for (cnt = 0; cnt < argc; cnt++){
printf(" param %d: %s\n", cnt, argv[cnt]);
}
char *buf = "My result";
dpdl_stack_buf_put(buf);
return 0;
}
<<
int exit_code = dpdl_exit_code()
println("embedded C exit code: " + exit_code);
string buf = dpdl_stack_buf_get("dpdlbuf_var1")
println("response buffer: " + buf)
println("")
println("embedding javascript...")
int val = 23
arr[] = [1, 2, 3, 4]
dpdl_stack_push(val, arr)
>>qjs
console.log('Dpdl sends a message with js');
var sa;
var arr;
var v;
if(scriptArgs.length > 1){
v = scriptArgs[0];
sa = scriptArgs[1];
arr = sa.split(",");
std.printf("val=%d\n", v);
console.log(arr);
}else{
sa = "";
}
for(let i = 0; i < arr.length; i++) {
std.printf("arr[%d]=%d\n", i, arr[i]);
}
<<
int js_exit_code = dpdl_exit_code()
println("embedded javascript exit code: " + js_exit_code);
Dpdl supports and runs on a wide range of platforms including the small footprint java virtual machine ‘miniJVM’, released as Open-Source, that can be compiled for almost every platform as soon as an ANSI C compiler is available for the target platform.
Java versions >= 1.4 and later
Java 1.1 (without ‘loadObj’ and ‘getObj’ methods)
J2ME MIDP (Mobile Information Device Profile) -> MIDP 1.0 and MIDP 2.0 (CLDC 1.0, CLDC 2.0)
Java ME CLDC & GCF (JSR 360)
Java ME Embedded Profile (JSR 361)
Platforms with ANSI C compiler where the Open Source java virtual machine (miniJVM) can be compiled
So far DpdlEngine V1.0 has been tested on:
Dpdl is currently developed by SEE Solutions and the following integrations has been defined:
The Dpdl framework and API documentation are available via the following links:
Dpdl embedded minimal C library Documentation
Visit official Dpdl-io repository on GitHub: DpdlEngine
Full features applications developed with Dpdl are published on this GitHub repository:
ROOT is a powerful Data Analysis Framework developed by CERN (https://root.cern/) .
ROOT C++ code can be embedded within Dpdl via the keyord ‘>>root’
Example Dpdl script embedding ‘ROOT C++’:
# main
println("test embedded ROOT C++...")
>>root
auto canvas = new TCanvas("c","Graph2D example",0,0,700,600);
double x, y, z, P = 6.;
int np = 200;
auto dt = new TGraph2D();
auto r = new TRandom();
for (int N=0; N<np; N++) {
x = 2*P*(r->Rndm(N))-P;
y = 2*P*(r->Rndm(N))-P;
z = (sin(x)/x)*(sin(y)/y)+0.2;
dt->SetPoint(N,x,y,z);
}
dt->Draw("tri1 p0");
canvas->Modified(); canvas->Update();
<<
int exit_code = dpdl_exit_code()
println("embedded ROOT exit code: " + exit_code)
Dpdl example that uses java.util.GZIP* classes to compress and de-compress data
# main
object str = loadObj("String", "my data to compress")
println("string to compress: " + str)
object byte_out = loadObj("ByteArrayOutputStream")
object zip_out = loadObj("GZIPOutputStream", byte_out)
println("compressing...")
zip_out.write(str.getBytes("UTF-8"))
zip_out.close()
println("data compressed successfully!")
object compressed_str = byte_out.toString()
println("compressed string: " + compressed_str)
println("decompressing...")
object byte_in = compressed_str.getBytes("UTF-8")
object byte_arr_in = loadObj("ByteArrayInputStream", byte_in)
object byte_arr_in_obj = cast(byte_arr_in)
object zip_in = loadObj("GZIPInputStream", byte_arr_in_obj)
object in_reader = loadObj("InputStreamReader", zip_in)
object buf_reader = loadObj("BufferedReader", in_reader)
string decompressed_str = ""
string line = ""
while(line != null)
line = buf_reader.readLine()
if(line != null)
decompressed_str = decompressed_str + line
fi
endwhile
println("decompressed: " + decompressed_str)
Example Dpdl script (Bluetooth device discovery using high level Dpdl API ):
int status = DPDLAPI_searchClientsOnServer()
int status_discovery = dpdlFalse
int service_discovery = dpdlFalse
int counter = 0
if(status == dpdlTrue)
while (status_discovery != dpdlTrue) && (service_discovery != dpdlTrue)
status_discovery = DPDLAPI_discoveryServerFinished()
service_discovery = DPDLAPI_serviceDiscoveryServerFinished()
print(".")
counter = counter+1
sleep(3000)
endwhile
string dev = "n"
int dev_found = 0
while(dev != "null")
dev = DPDLAPI_getServerVisibleBTAddr()
if(dev != "null")
println("bluetooth device visible: " + dev)
saveData(dev)
dev_found = dev_found + 1
fi
endwhile
else
println("No working Bluetooth stack found")
fi
Python code can be embedded within Dpdl script by using the keyword ‘>>python’.
println("testing embedding python code wihin Dpdl")
println("")
>>python
languages = ['Dpdl', 'C', 'Python', 'OCaml']
for language in languages:
print(language)
<<
# again Dpdl
println("")
int exit_code = dpdl_exit_code()
println("ebedded python exit code: " + exit_code);
Dpdl allows the embedding and on-the-fly compilation and execution of C code directly within Dpdl scripts.
The C code can be embedded and executed with 2 distinct Modes, either interpreted only OR compiled and executed in memory at runtime.
The two modes have distinct properties: The interpreted C code execution is for example more convenient for testing, small footprint and portability, while the compiled C code execution is more convenient for faster execution and for linking with external libraries. The execution of C code is driven by a native Dpdl library that has a small footprint and for the interpreted mode it includes all essential C libraries and language constructs (ISO standard C90), POSIX compliant) with no external library dependencies needed. Custom libraries and functions can be integrated and linked via a straight forward implementation configuration approach.
# main
# starting with Dpdl, pushing parameters on the stack and embedding C code
println("testing embedded C code in Dpdl")
int n = 6
double x = 10.0
string a = "test"
dpdl_stack_push(n, x, a)
>>c
#include <stdio.h>
int dpdl_main(int argc, char **argv){
printf("Hello C from Dpdl!\n");
printf("\n");
printf("num params: %d\n", argc);
int cnt;
for (cnt = 0; cnt < argc; cnt++){
printf(" param %d: %s\n", cnt, argv[cnt]);
}
return 0;
}
<<
# again Dpdl...
int exit_code = dpdl_exit_code()
println("embedded C exit code: " + exit_code);
object str = loadObj("String", "Dpdl embedded C")
bool b = str.contains("C")
println("Dpdl contains C: " + b)
This is a more complete example of the usage of embedded C code within Dpdl:
Julia is a powerful and performant computational programming language (https://julialang.org)
Julia code can be embedded within Dpdl via the keyord ‘>>julia’
#main
println("Testing Plot data with Julia programming language...")
>>julia
using Plots
x = range(0, 10, length=100)
y1 = sin.(x)
y2 = cos.(x)
p = plot(x, [y1 y2])
savefig(p, "./Test/myplot.pdf")
dispose_status = @ccall dpdl_julia_dispose()::Int32
return 1
<<
int exit_code = dpdl_exit_code()
println("finished with exit code: " + exit_code)
Other programming languages or natural language interpreters can be easily integrated in Dpdl via a dedicated plug-in interface and configuration. Please feel free to suggest yours favorite language on the Discussion section on the DpdlEngine GitHub repository
The ‘DpdlEngine lite’ release can be downloaded as Free trial shareware (with some limitation/restrictions) from the following download request form:
To buy a full featured ‘DpdlEngine lite’ license with no limitations/restrictions, regular updates and support, please submit your request via the following request form:
For custom requirements or a bulk reseller license write an e-mail to the contact address.
e-mail: info@dpdl.io