Awesome Sauce Java project video thumbnail
Replay with sound
Play with
$111 pledged of $3,500 goal
$111 pledged of $3,500 goal

What is a prototype?

A prototype is a preliminary model of something. Projects that offer physical products need to show backers documentation of a working prototype. This gallery features photos, videos, and other visual documentation that will give backers a sense of what’s been accomplished so far and what’s left to do. Though the development process can vary for each project, these are the stages we typically see:

Proof of Concept

Explorations that test ideas and functionality.

Functional Prototype

Demonstrates the functionality of the final product, but looks different.

Appearance Prototype

Looks like the final product, but is not functional.

Design Prototype

Appearance and function match the final product, but is made with different manufacturing methods.

Production Prototype

Appearance, function, and manufacturing methods match the final product.

4a2ca4ab6404bf93070f88952f32f25b original

Prototype Gallery

These photos and videos provide a detailed look at this project’s development.


Look for daily updates that highlight the rapid pace of development of Awesome Sauce Java...

Have a nice day ☺

Awesome Sauce Java is an implementation of interpreted Java that exposes the majority of the Java JDK. The compiler is designed and partially implemented to make seamless load of compiled code quiet - without restart. Much of the Java (8. SE JDK) language is available and working as-is. Testing is progressing and many Java methods run against their instance classes without fail.  

There are many classes that need bridge classes built to make elements available, such as graphics classes, JavaFx, Listeners and Threads. The parser is stable, but immature. It's going to take a 2-5 days to make rock-solid. The eval code likewise needs a 2-3 days of review. Many of the applications are works in progress, but will take a few weeks to construct, faster if the Awesome Sauce Builder (graphical interface builder) is as fast as the prototype. The majority of the three months is going to be focused on building bridge classes and testing: building test code and test applications. Building bridge classes provides the mechanism to facilitate method dispatch from internal implementation methods to Awesome Sauce Java interpreted code. 

Many of the core apps and components are designed. The compiler is designed and ready to build, as is the Awesome Sauce Doctor (self healing code.) If it sounds like a lot of work, it is. But the language and tools make it possible to fly. The goal is to get these tools into your hands quickly, because they're hot

It will take 3 months to build the first version of Awesome Sauce Java. It might be a late beta version, but it will be feature complete, highly tested, stable, and well-documented. What works will be known and documented, along with what doesn't. The release will include a suite of test code, test apps, and enough demo applications - real, working applications - to not only test the system, but provide an extensive collection of Awesome Sauce Java code for the release.

Will any parts of Java be missing?

So far, no. But, it's hard to know if there are areas that are going to be prohibitive to make work well. Awesome Sauce Java is proving itself to be incredibly fast and dynamic, while validating that the Awesome Sauce Java to Java interfaces are stable. A lot of design effort went into making the language leverage Java without modification, while improving stability. There are very few exceptions thrown that aren't caught and managed, allowing the runtime to maintain significantly better uptime than Java applications. Threads are always an area of concern.

Will it work with JDBC?

Yes. I had been testing the JDBC interfaces when a hard-drive crash caused me to lose the code. It was working well and will get built and included for the first release. I was also exploring client-server interactions via the GlassFish Server and will publish updates in the weekly newsletter regarding progress about these components and Awesome Sauce Java.

What other cool features should I know about?

Thee method calls can be localized. In fact, the goal of the system is to facilitate collaborative, real-time programming and in different languages, such that code written in a first language is displayed to co-collaborators in their native language as code is entered. The mechanism and Locale folders for the localized entries are already in place. It's a matter of localizing method names to make it work at the code level. The Editor is also going to encourage localizing as much of the display as possible. It's hoped that the combination of a license that encourages sharing, in combination with an environment that reduces linguistic barriers, will make hive programming, and more expressive applications and tools, possible.

The pairing of Awesome Sauce Builder and Awesome Sauce Editor operating and editing an application simultaneously may make it possible for non-tech and tech people to co-collaborate on app design and implementation simultaneously. How these applications come together will be updated in the weekly Awesome Sauce Newsletter.

A sketch of parallel processing applications is on the pile of work to do. It starts with a dispatching application and a set of supporting apps, each of which is configured for a set of libraries/packages and assigned to a processor.

What about modern features? The language is highly flexible. Concepts like concurrency and parallel processing have been considered. They will be implemented in a future version of Awesome Sauce Java as a natural extension of the language. The first version is intended to be focused on a stable Java release, running on a stable Java, with code that looks like, and is, standard Java. It's hoped that by providing a stable, interpreted Java that looks like Java, more people will be likely to take a look and explore. The language internals are very clean and malleable. A subsequent version could introduce a concurrent language as an extension or second language.

Awesome Sauce Java looks like Lisp, with some Smalltalk. What gives? 

 Awesome Sauce Java includes a wealth of Common Lisp functions and features. It might even contain a complete implementation of Common Lisp at the first release, or soon after. It turns out that Lisp with Java provides exceptional expressive power. Both languages are incorporated in their standard form to make it possible for people familiar with each to jump in and explore without having to learn a new language. But Awesome Sauce Java is Java and it exposes Java in an interpreted form. The Lisp part is a nice bonus, because Lisp offers a lot of opportunity to do things like AI, rules, runtime & realtime editing of applications, functions, methods, and classes. Plus, it stabilizes Java to the point where Java mostly doesn't crash. Hopefully, the first release won't crash at all. Point is, Awesome Sauce Java is Java, because Java is stable and has a great release format, but Lisp is a super-secret bonus that can be ignored by Java programmers until they start to learn some of the idioms and realize it's a powerful language that plays nice with Java. The combination of the two languages is where the magic happens, becoming a new language of its own. 

Applications and Tools The following tools are already works-in-process and will be released with Awesome Sauce Java 1.0. 

Awesome Sauce Interface Builder 

Quickly lay out working applications. Reattach to running applications and make modifications without having to stop-and-start. Generate code for stand-alone Java applications. 

Awesome Sauce Editor 

Edit and run Awesome Sauce Java code from within an environment made especially for the dynamic performance of the language. Attach to running applications, execute commands, and start processes. 

Awesome Sauce Terminal 

Connect from your favorite editor to the Awesome Sauce Terminal and run commands, start processes, and develop applications.

Task Manager & Demo Apps 

Track tasks and activities in a full-featured Awesome Sauce Java application built for making it fast to keep track of information and things to do. Plus, Awesome Sauce Java will be released with a set of demo applications, sample code, test suites, and any other widgets we can put in the package. 

Awesome Sauce Friends

There are a gazillion third party Java libraries, is there any chance they can be included with, or imported into, Awesome Sauce Java? Yes. It's possible that some of the major third party libraries, from Amazon, Google, Apache, and more, will be included with the first release of Awesome Sauce Java. There's no technical reason not to include them. The only limiting factor is testing time. The first release has to be functional, stable, and tested, and that represents a lot of work. If much of it can be automated, then it'll make it easier to take a look at third party libraries and begin to work with those whose licenses are friendly to the Awesome Sauce License.

The at-least weekly Awesome Sauce Newsletter

Released as often as it makes sense, full of updates, status, and news.

Future Plans

It's possible one, some, or all of the following applications and components will be in the first release, it's also possible they'll be released soon after. All who donate to the Awesome Sauce Crowd Funding campaign will be eligible to receive any or all when they're ready. 

Awesome Sauce OS

An editable OS. Runs on all OS's. Can be it's own OS on a wide range of computer and mobile devices. 

Hot Sauce 

Fast UI. Very fast UI. Built by a disabled man to simplify complexity, and wait'll you try it, it's Awesome Sauce with Hot Sauce! 

Awesome Sauce Doctor 

Self-modifying, self-healing code. Rules-based. AI. Designed and early prototype built. Looks pretty exciting as it makes it possible to build a suite of code for a code-point/function that responds to error conditions, exceptions, or other conditions, allowing for the modification of code at runtime based on rules. Could also be used for subscription, cron, update, and a wealth of code management-related functions. 

Awesome Sauce Shop 

The store for Awesome Sauce Java applications, modules, tools, and more. 

Awesome Sauce Transformers 

Hot swappable Function code, making it possible to extend the Awesome Sauce OS and applications with new features, bug fixes, and upgrades while they're running. 

Awesome Sauce Parallel Modules & Concurrency 

It's possible to configure an Awesome Sauce build with various Java core libraries. It's hoped that by building configurable apps and modules, that a system can be constructed that enables parallel or distributed processing, where a dispatch application (or set of) sends requests to specialized application configurations assigned to cores or processors in order to improve processing power. Awesome Sauce Java is Java, so all the threading of Java is available. Threading is always a challenge, so the threading model and concurrency, as well as other modern features, will be explored once the first version is stable and/or released. Concurrency is a complex issue. If it turns out it can be added in the first release, it will be added, but the plan is for concurrency to be considered after the first release.

The following listings show code that has been run through Awesome Sauce Java. They are hand-tested classes and instances I've used to verify performance, fix bugs, and add features.

// File

java > (setf *files* (new File "/home/michael/jdk/src/java")) /home/michael/jdk/src/java 

java > (setf *all-files* (list *files*)) [Ljava.lang.String;@3c756e4d 

java > (ascend *all-files* #'princ) 

 text net rmi applet nio lang awt sql beans math util security io time

 java > (get-name *files*) java

 java > (get-path *files*) /home/michael/jdk/src/java

 java > (get-total-space *files*) 245058105344

 java > (get-usable-space *files*) 208122343424

 java > (is-absolute *files*) true

 java > (is-directory *files*) true

 java > (is-hidden *files*) false

 java > (last-modified *files*) 1506374080000

 java > (length *files*) 4096 

java > (list-roots *files*) null 

java > (setf *path* (to-path *files*)) /home/michael/jdk/src/java 

java > *path* /home/michael/jdk/src/java

 java > (toURI *files*) file:/home/michael/jdk/src/java/ 

java > (exists *files*) true 

java > (get-absolute-file *files*) /home/michael/jdk/src/java

 java > (get-parent *files*) /home/michael/jdk/src 

java > (get-parent-file *files*) /home/michael/jdk/src

 java > // java.lang.Math 

java > (Math.abs -21123.3023) 21123.3023

 java > (Math.acos -17.322) NaN 

java > (Math.acos 0.55) 0.9884320889261531

 java > (Math.acos -0.55) 2.15316056466364

 java > (Math.addExact 12345 49495) 61840 

java > (Math.asin 1.0) 1.5707963267948966 

java > (Math.asin -1.0) -1.5707963267948966

 java > (Math.atan 1.0) 0.7853981633974483

 java > (Math.atan2 1.0 2.0) 0.4636476090008061 

java > (Math.cbrt 2.0) 1.2599210498948732 

java > (Math.ceil (Math.cbrt 2.0)) 2.0 

java > (Math.copySign 123.030 -1203.40) -123.03

 java > (Math.cos 0.2341) 0.9727235061230322 

java > (Math.cosh 1.073) 1.6330599023380639

 java > (Math.decrementExact 173994) 173993 

java > (Math.exp 2.737) 15.440593762844655 

java > (Math.expm1 2.737) 14.440593762844655 

java > (Math.floor (Math.expm1 2.727)) 14.0 

java > (Math.getExponent 76.38872) 6

 java > (Math.hypot 4.37 8.838) 9.859368336764785 

java > (Math.iEEEremainder 17.440 13.994) 3.4460000000000015

java > (Math.log 239923.1003) 12.388073735563474

 java > (Math.log10 2340023.10211) 6.369220145046624

 java > (Math.log1p 23400.02304) 10.060535020048237 

java > (Math.max 230.2340 23.230) 230.234 

java > (Math.min 234.03 12123.302) 234.03 

java > (Math.nextAfter 1231.03 233224.032) 1231.0300000000002

 java > (Math.nextDown 23420.023) 23420.022999999997 

java > (Math.pow 21.23 12.23) 1.692771851356702E16 

java > (Math.random) 0.6284755222833167 

java > (Math.rint 234.0230) 234.0 

java > (Math.round 12.23423) 12 

java > (Math.scalb 2343.23 23) 1.965643792384E10 

java > (Math.signum 3.3040) 1.0 

java > (Math.sin 2.21) 0.8025710662467472 

java > (Math.sinh 0.388) 0.39780872051201877

 java > (Math.sqrt 17.9393) 4.235481082474575

 java > (Math.tan 1.230) 2.819815734268152

 java > (Math.tanh 1.2010) 0.8339593728373399

 java > (Math.toDegrees 12.300) 704.7380880109125 

java > (Math.toRadians 12.300) 0.21467549799530256

 java > (Math.ulp 2343.340) 4.547473508864641E-13 

// StringBuffer

 java > (setf sbuff (new StringBuffer "hey my buffer!")) hey my buffer! 

java > (append sbuff 'a') hey my buffer!A'

 java > (append sbuff true) hey my buffer!A'true

 java > (append sbuff (Math.cos 1.0)) hey my buffer!A'true0.5403023058681398

 java > (append sbuff 777) hey my buffer!A'true0.5403023058681398777

 java > (append sbuff (new string "my string")) hey my buffer!A'true0.5403023058681398777my string 

java > (capacity sbuff) 62

 java > (codePointAt sbuff 12) 114

 java > (codePointBefore sbuff 12) 101

 java > (codePointCount sbuff 1 4) 3

 java > (delete sbuff 3 9) heyffer!A'true0.5403023058681398777my string

 java > (ensureCapacity sbuff 100) null 

java > (capacity sbuff) 126

 java > (index-of sbuff "my") 35 

java > (index-of sbuff "7") 32 

java > (index-of sbuff "7" 32) 32 

java > (index-of sbuff "7" 33) 33 

java > (insert 7 true) null

 java > (insert sbuff 7 true) heyffertrue!A'true0.5403023058681398777my string

 // Collections, just a small sampling

 java > (setf *zhashmap* (new hash-map)) {} 

java > (put *zhashmap* "one" 1) null  

java > (put *zhashmap* "two" 2.0) null  

java > (put *zhashmap* 3 "a string") null

java > (put *zhashmap* 'list '(1 2 3)) null  

java > (keySet *zhashmap*) [3, one, two, LIST]

java > (entrySet *zhashmap*) [3=a string, one=1, two=2.0, LIST=(1 2 3)]  

java > (remove *zhashmap* "one") 1  

java > (size *zhashmap*) 3

java > (isEmpty *zhashmap*) false java > (setf *zhashset* (new hash-set)) []

java > (add *zhashset* "one") true

java > (add *zhashset* 2) true

java > (add *zhashset* (new JFrame "test")) true

java > (add *zhashset* 'symbol) true  

java > (setf *zlinked* (new LinkedList)) []  

java > (mapcar #'(lambda (v) (add *zlinked* v)) '(1 2 3 "four" "five" "six" #'test-function))  

(true true true true true true true)  

java > (ascend *zlinked* #'princ) 

1 2 3 four five six #'test-function  

java > (descend *zlinked* #'princ) ; descending iterator #'test-function  

six five four 3 2 1 1  

java > (setf *ral* (new ArrayList)) []  

java > (add *ral* 1) true  

java > (add *ral* 2) true  

java > (add *ral* 3) true  

java > (add *ral* 4) true // Currency  

java > (setf *curr* (Currency.getInstance (Locale.getDefault))) USD  

java > (get-display-name *curr*) US Dollar  

java > (get-currency-code *curr*) USD  

java > (get-default-fraction-digits *curr*) 2  

java > (get-numeric-code *curr*) 840  

java > (get-symbol *curr*) $  

java > (to-string *curr*)  


// DoubleSummaryStatistics  

java > (setf *dbl-stats* (new DoubleSummaryStatistics))

DoubleSummaryStatistics{count=0, sum=0.000000, min=Infinity, average=0.000000, max=-Infinity}  

java > (accept *dbl-stats* 1.7) null  

java > (mapcar #'(lambda (v) (accept *dbl-stats* v)) '(1.25 1.99 2.013 0.948 1.657))  


java > (get-average *dbl-stats*) 1.593  

java > (get-count *dbl-stats*) 6  

java > (get-max *dbl-stats*) 2.013  

java > (get-min *dbl-stats*) 0.948  

java > (get-sum *dbl-stats*) 9.558  

java > (to-string *dbl-stats*)

DoubleSummaryStatistics{count=6, sum=9.558000, min=0.948000, average=1.593000, max=2.013000} // Package  

java > (setf pkgs (Package.getPackages))


java > (get-annotations (Array.get pkgs 0))


java > (get-implementation-vendor (Array.get pkgs 0))

Oracle Corporation  

java > (get-implementation-version (Array.get pkgs 0))


java > (get-name (Array.get pkgs 0))  


java > (getSpecificationTitle (Array.get pkgs 0))

Java Platform API Specification  

java > (getSpecificationVersion (Array.get pkgs 0))


java > (isSealed (Array.get pkgs 0))  


Risks and challenges

The risks are in the bus number: 1. The project is written by a guy, on a computer, in a room. That's the biggest risk.

The language itself is actively being used and works as advertised. There is a significant amount of work to do to middleware, but one guy exposed the whole of Java in an interpreted format, so the middle sauce should be okay. There may be issues with threading and synchronization, but until experiments can be performed, it looks doable, but there might be a gotcha or a hitch somewhere.

Learn about accountability on Kickstarter

Questions about this project? Check out the FAQ


  1. Select this reward

    Pledge $10 or more About $10

    Awesome Sauce Backer

    Receive the at-least weekly Awesome Sauce Newsletter and the first release of Awesome Sauce Java.

    Estimated delivery
    0 backers
    Kickstarter is not a store.

    It's a way to bring creative projects to life.

    Learn more about accountability.
  2. Select this reward

    Pledge $20 or more About $20

    Awesome Sauce Solid

    All the Awesome Sauce our backers get, plus a keychain.

    • Awesome Sauce Keyring
    Estimated delivery
    Ships to Only United States
    0 backers
    Kickstarter is not a store.

    It's a way to bring creative projects to life.

    Learn more about accountability.
  3. Select this reward

    Pledge $40 or more About $40

    Awesome Sauce Double Solid

    All the Awesome Sauce our backers get, plus an Awesome Sauce Java tee shirt

    • Awesome Sauce Keyring
    • Awesome Sauce T-Shirt
    Estimated delivery
    Ships to Only United States
    0 backers
    Kickstarter is not a store.

    It's a way to bring creative projects to life.

    Learn more about accountability.
  4. Select this reward

    Pledge $100 or more About $100

    Get Me Some Awesome Sauce

    All the gifts, but you want the code. Get the first stable early beta release.

    • Awesome Sauce Hat
    • Awesome Sauce Keyring
    • Awesome Sauce T-Shirt
    Estimated delivery
    Ships to Only United States
    1 backer
    Kickstarter is not a store.

    It's a way to bring creative projects to life.

    Learn more about accountability.
  5. Select this reward

    Pledge $1,000 or more About $1,000

    Make It Awesome Sauce

    You want to make sure it gets built. Email access and early releases.

    • Awesome Sauce Hat
    • Awesome Sauce Keyring
    • Awesome Sauce T-Shirt
    Estimated delivery
    Ships to Only United States
    0 backers
    Kickstarter is not a store.

    It's a way to bring creative projects to life.

    Learn more about accountability.

Funding period

- (7 days)