Dpdl is a rapid development programming language and constrained device framework with built-in database technology.
The Dpdl language constructs and syntax is simple and intuitive, yet powerful, with an object oriented paradigm (OOP), interoperable with java JVM platform APIs and external Native shared libraries.
Dpdl comes as a very compact and portable execution engine (DpdlEngine) with an extensible API interface that enables to execute Dpdl code, as well as code in other programming languages or any custom syntax directly embedded within the same Dpdl source code, simultaneously and of multiple types.
Dpdl provides access to java platform API’s, Native shared libraries, Wasm modules and GPU compute and enables the embedding and execution of multiple programming languages like C, C++, Python & MicroPython, Julia, JavaScript, Lua, Ruby, Java, PHP, Perl, Groovy,V, Clojure, Modelica, Wgsl and OpenCL, directly embedded within Dpdl code. Everything comes already included with the DpdlEngine, No additional installations required.
The core Dpdl engine has the capability to run also on memory constrained devices and platforms via a dedicated kilobyte range virtual machine.
Dpdl is Self contained, Compact, Portable and Highly customizable
Dpdl itself is a multi-purpose programming language, self-contained, interpreted and in part also dynamically bytecode compiled, statically as well as dynamically typed, with a very compact memory footprint and portable to most platforms. There is an on-going development to enable Dpdl code to be compiled also directly to native code for multiple target platforms.
In addition Dpdl introduces the concept of embedded code sections that can be executed within Dpdl code. It allows to create and integrate custom syntax and language interpreters of all sorts in form of ‘Dpdl language plug-ins’, for example code in other programming languages.
Multiple ‘Dpdl language plug-ins’ are currently available, for example the ‘Modelica’ language for cyber-physical simulations is also available as ‘Dpdl language plug-in’. Further Dpdl language plug-ins are currently in active development, for example to enable also Quantum Computing directly inside Dpdl via embedded OpenQWASM code.
The included Dpdl language plug-in ‘DpdlAINerd’ (DAN) enables to automatically generate via AI generative code programming language code and content or data, embed it automatically within Dpdl code and execute the code right away. Alternatively the generated code can also be rewritten to a new file and executed in a subsequent step.
Further, the custom ‘DpdlPacket’ data container with built-in database technology provides a convenient way to package, handle and query data efficiently on memory scarce devices.
DpdlEngine stack overview
Common IoT protocol stacks such as Bluetooth™ and CoAP (Constrained Application Protocol) are integrated by default and third party libraries and protocols can be added as extensions.
Dpdl provides a simple access to java API’s, Native shared libraries, Wasm modules and GPU compute.
The included Dpdl language plug-in ‘DpdlAINerd’ (DAN) enables to make use of AI generative code to automatically generate and embed executable code and content or data by means of natural language descriptions contained inside Dpdl code.
Further, Dpdl can be used to encode, store, control and query data efficiently also on small memory footprint devices via a custom data container defined as ‘DpdlPacket’.
Dpdl enables the integration of different technologies to leverage fast prototyping and foster research and development.
Dpdl can be used as:
Rapid application development platform
Embedded scripting engine
Development of Domain Specific Languages (DSL)
Data handling on memory constrained devices
AI generative code
Library module
Testing framework for heterogeneous code bases
Utility tool
DpdlEngine is optimized to run on a wide range of platforms (JavaME, J2SE, any all VMs >= 1.4 Spec). The core engine runs also on Java 1.1 spec compliant VMs. This makes it possible to run Dpdl also on very small footprint Virtual Machines (eg. JamVM, miniJVM, and others).
Dpdl API provides access to the complete underlying Java JVM/JRE platform API’s and to external java and Native shared libraries
Multiple ‘Dpdl language plug-ins’ available (embeddable programming languages): C, C++, Python, MicroPython, Julia, JavaScript, Lua , Ruby, Java, PHP, Perl, Groovy, Clojure, Modelica, Wgsl and OpenCL programming language code can be embedded and executed directly within Dpdl code (interpreted/compiled code)
No additional installations required (except user libraries)
Further programming languages and syntax interpreters can be embedded via a dedicated kernel execution interface in form of plug-ins (see ‘DpdlCustom’ tag in DpdlEngine.ini)
Includes embedded C compiler: On-the-fly compilation of embedded ANSI C code in memory at runtime (for different targets: i386, x86_64, RISC-V, ARM and TMS320C67xx) -> very Fast compile time!!!
Wasm runtime Dpdl language plug-in included allows to access ‘Wasm’ module functions from Dpdl and from embedded language code. Also WAT code can be directly compiled on-the-fly and executed.
Built-in Dpdl scripting engine with support for custom extensions -> allows to dynamically add language features at runtime
Dpdl C API enables to execute Dpdl code embedded within programs written in C
On the fly conversion/compilation of Dpdl types ‘class’ and ‘struct’ into native java bytecode classes
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
XML with XPath parser
JSON
Easy integration of custom libraries
Small footprint, Only 372 Kb
for DpdlEngine -> can be stripped down to 80 Kb
for minimal setup
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 programming language plug-ins
For more Info visit the official Dpdl-io repository on GitHub:
DpdlEngine
Prototype sample applications implemented with Dpdl can be found on this GitHub repository:
Dpdl-sample-Apps
Dpdl provides API functions to load and access java objects and methods of the underlying java JVM 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 and executed within the same Dpdl code via the keyword >>
.
Further programming languages and syntax interpreters can be developed and integrated via a dedicated plug-in interface and configuration if form of Dpdl language plug-ins.
This enables basically every sort of programming language or natural language syntax interpreter to be embedded and executed directly within Dpdl code.
This features is very useful for rapid development and rapid prototyping and is also a key feature for generative code.
C
code (interpreted) --> minimal subset of C90 with standard C libs included
C
code (compiled ) --> ISO C99 standard, compiled in memory and dynamically executed at runtime (see ‘dpdl:compile’)
Python
MicroPython
(ideal for embedded systems)
Julia
JavaScript
Lua
Ruby
OCaml
Java
PHP
Perl
Groovy
Clojure
Modelica
C++
available add-on ‘Dpdl language plug-ins’:
Wasm
-> WAT Compiler and Wasm Runtime
Sql
-> query databases via SQL
Wgsl
-> WebGPU shading language (WGSL)
OCL
-> Open Computing Language (OpenCL)
Ai
-> see doc/DpdlAINerd.md
In development ‘Dpdl language plug-ins’ (available soon in coming releases):
quantum
-> OpenQWASM compiler and executor to leverage Quantum Computing capabilitiesSample Dpdl code 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)
>>js
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 runs on a wide range of platforms and includes also a small footprint kilobyte range java virtual machine that can be compiled for almost every platform as soon as an ANSI C compiler is available for the target platform.
Java ME CLDC & GCF (JSR 360)
Java ME Embedded Profile (JSR 361)
Java versions >= 1.4 and later
Java 1.1 - 1.3 (without ‘loadObj’ and ‘getObj’ methods)
All Platforms where the Open Source virtual machines ‘JamVM’ and ‘miniJVM’ can be compiled
Platforms with ANSI C compiler where the included kilobyte range java virtual machine can be compiled
So far DpdlEngine V1.0 has been tested on:
Dpdl is currently developed by SEE Solutions and the following integrations are in development:
Back-end compiler to compile Dpdl code to native machine code for most target architectures (LLVM)
Dpdl-IDE with plug-ins for popular IDEs (IntelliJ, eclipse, VS Code)
Development of a dedicated ‘Dpdl language plug-in’ for enabling Quantum Computing via embedded OpenQASM 2.0 (Circuit description language) code within Dpdl
The Dpdl framework and API documentation are available via the following links:
Dpdl embedded minimal C library Documentation
Visit also the official Dpdl-io repository on GitHub for updates: DpdlEngine
Full featured 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 code embedding C++ with libs ‘ROOT’:
# 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)
The following simple Dpdl example shows how the type class
can make use of Inheritance and Polymorphism. Some functions in this example make use of embedded code sections implemented in ‘Java’ and ‘C’
struct property {
int max_weight_gr
float max_height_m
string desc = null
}
class Animal {
int id
string name
struct property info = {100000, 2.5,.}
func Animal(int id_)
id = id_
name = "No name"
println("new Animal() with id: " + id + " info: " + info)
end
func Animal(int id_, string name_)
id = id_
name = name_
println("new Animal with id: " + id + " and name: " + name + " - info: " + info)
end
func print()
println("This is an Animal")
end
func makeSound()
println("kind of animal is not defined")
end
func getHashMap()
object h_map = loadObj("HashMap")
info_arr[] = array(info)
int i = 0
for(i < info_arr.size())
h_map.put(i, info_arr[i])
i=i+1
endfor
return h_map
end
}
class Dog : Animal {
func Dog(int id_, string name_)
super(id_, name_)
info.max_weight_gr = 8000
info.max_height_m = 0.5
info.desc = "this breed is Shitzu"
println("new Dog() with id: " + id + " and name: " + name + " - info: " + info)
end
func print()
println("This is a Dog with name: " + name)
end
func makeSound()
println("WOOF WOOF")
end
func makeSound(int times) int
int ret_val
dpdl_stack_push(times)
>>java
int iter = arg0.intValue();
for(int i = 0; i < iter; i++){
System.out.println("WOOF");
}
return 1;
<<
ret_val = dpdl_exit_code()
return ret_val
end
}
class Cat : Animal {
func Cat(int id_, string name_)
super(id_, name_)
info.max_weight_gr = 1000
info.max_height_m = 0.25
info.desc = "thie breed is Siamese"
println("new Cat() with id: " + id + " and name: " + name + " - info: " + info)
end
func print()
println("This is a Cat with name: " + name)
end
func makeSound()
println("MIAUU MIAUU")
end
func makeSound(int beep) int
int ret_val
dpdl_stack_obj_put("iter", beep)
dpdl_stack_push("dpdl:applyvars")
>>c
#include <stdio.h>
#include <unistd.h>
// we output the character to ring 'bell' in the console
for(int i = 0; i < {{iter}}; i++){
putchar('\a');
}
return 23;
<<
ret_val = dpdl_exit_code()
return ret_val
end
}
# main
println("testing class type Inheritance and Polymorphism...")
println("")
class Animal ani(1)
ani.print()
ani.makeSound()
println("")
class Dog mydog(2, "Rosa")
mydog.print()
mydog.makeSound()
int sd = mydog.makeSound(100)
object map_dog = mydog.getHashMap()
println("map dog: " + map_dog)
println("")
class Cat mycat(3, "Minni")
mycat.print()
mycat.makeSound()
int sc = mycat.makeSound(3)
object map_cat = mycat.getHashMap()
println("map cat: " + map_cat)
println("")
println("finished")
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 code that performs Bluetooth device discovery using high level Dpdl BT 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 in form of ‘Dpdl language plug-ins’. Please feel free to suggest yours favorite language on the Discussion section on the DpdlEngine GitHub repository
The ‘DpdlEngine lite’ release can be requested as Free trial shareware (with some limitation/restrictions) at the following request form:
The ‘DpdlEngine pro’ instead is available with custom licensing models only.
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