This micro-blog will be covering development journey of the project called "Neon" that I've been working on. And I want to talking about this project briefly for now. But the future posts will be covering detailed information and development phases.

Neon is a project that contains a programming language design, its's compiler, a virtual machine and runtime core. It is being coded completely from the scratch. As of November 29th, the project is in the pre-alpha phase. And I expect that in a month or two the project going to be alpha stage. After 2 years of work, the project will have reached a huge milestone.

The programming language will be aiming programmers to focus productivity. That is the key feature of the language itself. To achieve that, most of things will be integrated into the language's nature. For example, threading. Today's modern programming languages does threading quite painful way except few languages such as Go programming language. (That's why I love go lang ) Most of them, you have to call or use threading class or API with a function reference/pointer or worker context. Some of these programming languages adds extra feature or classes into their frameworks to be simplify, but usually they are not really effective. Because their native approaches and rules does not allow it. Same issue can be said for the synchronization primitives, shared memory I/O, IPC and more..

The programming language -- will be referred as "neon" for now -- will be providing those capabilities in it's natural way. Today's standards obviously requisites online approaches even in the programming field. Hence, the neon will be planned to make easier network oriented programming and it let you focus what you want to achieve it. I will dive deep about the language's details in future posts. Neon designed VM managed, statically typed language but I'm planning to making it close to the system level as well. (I'm still thinking, designing the best way to do that.) I'm not share anything about the language's syntax structure for now because, in the current stage of development (pre-alpha), it can be change often.

Another design key about the Neon is simplicity. Simplicity lets programmers focusing their programming logic. Loops, for example.Llanguage will be providing unified single loop keyword with flexible usage. Or synchronization primitives.. Neon will be providing traditional way of using synchronization primitives for more complex implementation cases but it also gives ability to quite simply way of these. Because the most of the time the synchronization primitives are used to protect or limit with the certain number of threads of a specific code blocks. In such a case, creating lock objects, initializing them, acquire and release steps are quite boring and time wasting things.And that prevents programmers from focusing their logic. Neon aims to bring a native solution to that kind of situations.

As an experiment, the language syntax will be also supported by the Turkish based keywords. But the mainly focused design and development of the language will be going with the standard english keywords.Turkish keywords will be evaluated as an alias. So you may ask why? Let me answer this possible question shortly. Actually that was my utopia. I have been dreamed how would be like programming in the Turkish since I started programming. Another and the most important reason is to letting children who speaks the Turkish as the mother language like me, meet fast and easy with the programming logic in their mother language and providing the comparative way to do that and let them gaining programming skills at an early age. That could be a step for them to reach another programming languages, I thought.

The NeonLight compiles into the Common Instruction Set (CIS) which is being designed by me and binaries will be compiled as the native operating system's executable file format. So, the NeonLight will have compiling into PE, ELF and Mach-O executable file formats.

Native executables initiates the Neon's Virtual Machine to run programs on the system. Virtual Machine and its runtime (will be referring as NeonCore) takes place and does its job. NeonCore's JIT Compiler rapidly translates CIS (Common Instruction Set) to the CPU Architecture's Instruction set that it working on.

NeonCore is designing to run multiple CPU architecture and multiple operating systems. It supplies a lower level layer named "PAL" (Platform Abstraction Layer) to its higher layer. the PAL implements the platform specific logics.

Planned OS'es and architectures of the project are as follows:

CPU Architectures:

  • Intel x86
  • Amd64 (aka x64, x86-64)
  • ARM32
  • ARM64 (aka AArch64)

Operating Systems:

  • Windows (NT based)
  • Linux Kernel based OS'es
  • Android
  • macOS (XNU-Darwin)
  • BSD based systems (FreeBSD, OpenBSD, NetBSD, Dragonfly etc.)
  • Debian based systems (Raspbian for example)

IOT (Internet Of Things) and embedded devices

The NeonCore designed to work with the various type of embedded and IOT devices. The first fully supported device will be Raspberry PI and the NeonCore will be natively supporting GPIO programming capabilities.

I will share contents about the features and the development stages one by one over time but for now that's all. But before I finish, I want to share some statistic info about the project. I hope these stats gives you idea about the project's progression.

  • This project have been developing for 2 years.
  • The compiler part (NeonLight) being written in C#, the virtual machine and runtime core (NeonCore) part being written in C.
  • Hosted on Github as private repository.
  • Uses CMake to make the build process same on every platform. (Highly recommended)

Stay tuned for more, if you want to contact me for anything check out to find out available contact methods.