Latest news:

Welcome to the Atlas toolkit web site

What is the Atlas toolkit?

The Atlas toolkit provides a new way to handle web front-ends in a manner which facilitates the prototyping of web applications. In particular:

  • by allowing to run web applications with minimal installation and no upload,
  • by offering a wide choice of languages for developing web front-ends.

Web applications based on the Atlas toolkit, when launched on any computer which has access to internet (no need to be accessible from internet), will be accessible from every device with an access to internet. You have nothing to upload or install on a remote server. Simply launch your web application on your computer connected to internet, and it will be accessible from everywhere on internet.

The Java, Node.js, PHP and Python bindings are the proof that the Atlas toolkit can be provided for a large variety of languages. Works are in progress for the toolkit to be available for other languages, and if you wish to discuss about those perspectives, you are welcome to do so in this forum.

Hello, World! - a simple example

Here a preview of the famous "Hello, World!" program made with the Atlas toolkit:

Hello World! preview

Like all "Hello, World!" applications, this one focuses on the basics too. For a live demonstration: http://q37.info/runkit/Hello.

Below the source code of this application for the different available languages:

Java source code

import info.q37.atlas.*;
import java.util.HashMap;
import java.nio.file.*;

class Hello extends Atlas {
  public void handle(DOM dom, String action, String id) {
    switch (action) {
    case "Connect":
      try {
        dom.setLayout("", new String(Files.readAllBytes(Paths.get("Main.html"))));
        dom.focus("input");
      } catch (Exception e) {
        System.out.println(e.getStackTrace());
      }
      break;
    case "Typing":
      dom.setContent("name", dom.getContent(id));
      break;
    case "Clear":
      if (dom.confirm("Are you sure ?"))
        dom.setContents(new HashMap<String, String>() {
          {
            put("input", "");
            put("name", "");
          }
        });
      break;
    }
  }

  public static void main(String[] args) throws Exception {
    launch("Connect", "" );

    for (;;)
      new Hello();
  }
}

To install this example, among others: http://github.com/epeios-q37/atlas-java/.

JavaScript source code for Node.js

const atlas = require('atlastk');
const fs = require('fs');

const callbacks = {
  "Connect": (dom, id) => dom.setLayout("", fs.readFileSync("Main.html", "utf8"),
    () => dom.focus("input")),
  "Typing": (dom, id) => dom.getContent(id,
    (name) => dom.setContent("name", name)),
  "Clear": (dom, id) => dom.confirm("Are you sure ?",
    (answer) => { if (answer) dom.setContents({ "input": "", "name": "" }) })
};

atlas.launch(() => new atlas.DOM(), "Connect", callbacks);

To install this example, among others: http://github.com/epeios-q37/atlas-node/.

You can also launch npm install, create a Hello.js file with above source code, or retrieve this file at http://q37.info/downlaod/assets/Hello.js, and then launch node Hello.js.

PHP source code

<?php
require "phar://Atlas.phar/Atlas.php";

class Hello extends Threaded {
 public function handle($dom, $action, $id) {
  switch ($action) {
  case "Connect":
   $dom->setLayout("", file_get_contents("Main.html"));
   $dom->focus("input");
   break;
  case "Typing":
   $dom->setContent("name", $dom->getContent($id));
   break;
  case "Clear":
   if ($dom->confirm("Are you sure?")) {
    $dom->setContents(["input" => "", "name" => ""]);
   }
   break;
  }
 }
}

function hello() {
 return new Hello();
}

Atlas::launch("Connect", 'hello');
?>

To install this example, among others: http://github.com/epeios-q37/atlas-php/.

Python source code

import Atlas

def acConnect(this, dom, id):
  dom.setLayout("", open("Main.html").read())
  dom.focus("input")

callbacks = {
    "Connect": acConnect,
    "Typing": lambda this, dom, id:
      dom.setContent("name", dom.getContent(id)),
    "Clear": lambda this, dom, id:
      dom.setContents( {  "input": "", "name": ""} )
      if dom.confirm( "Are you sure ?" ) else None
  }

Atlas.launch("Connect", Callbacks)

To install this example, among others: http://github.com/epeios-q37/atlas-python/.

HTML file

This is the content of the Main.html file, which content is given as parameter to the setLayout(...) function in above source codes.

<fieldset>
 <label>Name:</label>
 <input id="input" maxlength="20" placeholder="Enter a name here" type="text" data-xdh-onevent="input|Typing" />
 <button data-xdh-onevent="Clear">Clear</button>
 <hr />
 <h1>
  <span>Hello </span>
  <span style="font-style: italic;" id="name"></span>
  <span>!</span>
 </h1>
</fieldset>

Other examples

For comparison, the application from the TodoMVC project has been developed using the Atlas toolkit. This is what it looks like:

Here are all available live demonstrations of applications made with the Atlas toolkit:

Although applications based on the Atlas toolkit will work on all modern browser, including Microsoft Edge, there are limitations (or bugs?) in the latter preventing its use to launch the live demonstrations. So, Microsoft Edge can be used for Atlas toolkit based applications, but not to launch their live demonstrations. Some more details can be found in the FAQ.

How does it work?

The library

On the launching of the application, or to update broad parts of the interface, the needed HTML code is sent directly to the browser; this is very similar to a CGI based application. Otherwise, only the needed part of the DOM is updated, like a single-page application. With the Atlas toolkit, you have the best of both worlds.

The HTML code can be generated using XSLT, manually, or by using the template engine of your choice.

Here are where you will find the source code of the library, with examples of use:

Remote server

Web applications usually need to be installed on a server which have to be accessible from internet. And, in addition of the application itself, there is also the need of a web server, standalone or embedded in the application, which handles the user's web browser requests.

By using the Atlas toolkit, you only have to launch your web application on your computer, and you can give access to your application to whoever is on internet. As you don't have to deploy your application on a remote computer, each modification you make to your application is instantly available. That's why the Atlas toolkit is particularly suitable for prototyping.

To achieve this, the Atlas toolkit connects to a free public server, which also handles the connections from the user's web browser. The URL corresponding to your application is displayed in the console from which you launched your application, and by simply giving this URL to someone on internet, you grant this person the access to your application.

The sources of the software on the remote server can be found here:

Behind the Atlas toolkit

The lead developer behind the Atlas toolkit is Claude SIMON, a freelance software engineer who lives near Strasbourg, in France.

He developed C++ libraries to handle desktop user interfaces using XULRunner. As XULRunner were discontinued, he switched to the newly standardized HTML5, along with the Chromium Embedded Framework. The libraries were then improved to also handle web user interfaces. Finally, Electron replaced the Chromium Embedded Framework.

As most of the popular languages are interpreted ones, he also specialized in improving the performances of this languages, by developing binding libraries simplifying the use of the more efficient C++ native code with this languages.

About the Atlas toolkit

Others

License

The Atlas toolkit is free software, released under the GNU AGPL. If this license doesn't meet your needs, feel free to ask about another one on the contact page.