Build better sotware, faster
With NeoBASIC, developers can build more robust solutions in less time, surpassing existing languages on the market in terms of productivity and quality.
Learn Faster
NeoBASIC has a simple, readable, and highly expressive syntax, similar to human language, as well as an extremely intuitive API. This allows beginners to focus more on programming concepts and less on complex writing rules. The language also values elegance and conciseness, promoting solutions that do “a lot with a little”.
Code Faster
NeoBASIC was created with the principle that programmers should feel happy while programming, allowing for much more agile and assertive development. Its dynamic coding and lack of compilation make it ideal for rapid prototyping of scripts and applications that need to be created or tested more urgently.
Run Faster
NeoBASIC is transpiled into C++, a language known for producing high-performance executables, with an extremely lightweight runtime and full resource control. By compiling directly to native code, NeoBASIC programs produce optimized binary executables without relying on virtual machines.
#
pcpp::PcapFileReaderDevice pcapReader("input.pcap");
pcapReader.open();
#
pcpp::PcapNgFileWriterDevice pcapNgWriter("output.pcapng");
pcapNgWriter.open();
#
pcpp::RawPacket rawPacket;
#
while (pcapReader->getNextPacket(rawPacket)) {
pcapNgWriter.writePacket(rawPacket);
}
#
#
pcpp::Packet parsedPacket(&rawPacket);
#
if (parsedPacket.isPacketOfType(pcpp::IPv4)) {
#
pcpp::IPv4Address srcIP =
parsedPacket.getLayerOfType()->getSrcIPv4Address();
pcpp::IPv4Address destIP =
parsedPacket.getLayerOfType()->getDstIPv4Address();
#
std::cout <<
"Source IP is: " << srcIP << std::endl <<
"Dest IP is: " << destIP << std::endl;
#
#
pcpp::PcapFileReaderDevice pcapReader("input.pcap");
pcapReader.open();
#
pcpp::PcapNgFileWriterDevice pcapNgWriter("output.pcapng");
pcapNgWriter.open();
#
pcpp::RawPacket rawPacket;
#
while (pcapReader->getNextPacket(rawPacket)) {
pcapNgWriter.writePacket(rawPacket);
}
#
#
pcpp::Packet parsedPacket(&rawPacket);
#
if (parsedPacket.isPacketOfType(pcpp::IPv4)) {
#
pcpp::IPv4Address srcIP =
parsedPacket.getLayerOfType()->getSrcIPv4Address();
pcpp::IPv4Address destIP =
parsedPacket.getLayerOfType()->getDstIPv4Address();
#
std::cout <<
"Source IP is: " << srcIP << std::endl <<
"Dest IP is: " << destIP << std::endl;
#
#
pcpp::PcapFileReaderDevice pcapReader("input.pcap");
pcapReader.open();
#
pcpp::PcapNgFileWriterDevice pcapNgWriter("output.pcapng");
pcapNgWriter.open();
#
pcpp::RawPacket rawPacket;
#
while (pcapReader->getNextPacket(rawPacket)) {
pcapNgWriter.writePacket(rawPacket);
}
#
#
pcpp::Packet parsedPacket(&rawPacket);
#
if (parsedPacket.isPacketOfType(pcpp::IPv4)) {
#
pcpp::IPv4Address srcIP =
parsedPacket.getLayerOfType()->getSrcIPv4Address();
pcpp::IPv4Address destIP =
parsedPacket.getLayerOfType()->getDstIPv4Address();
#
std::cout <<
"Source IP is: " << srcIP << std::endl <<
"Dest IP is: " << destIP << std::endl;
#
#
pcpp::Packet parsedPacket(&rawPacket);
#
if (parsedPacket.isPacketOfType(pcpp::IPv4)) {
#
pcpp::IPv4Address srcIP =
parsedPacket.getLayerOfType()->getSrcIPv4Address();
pcpp::IPv4Address destIP =
parsedPacket.getLayerOfType()->getDstIPv4Address();
#
std::cout <<
"Source IP is: " << srcIP << std::endl <<
"Dest IP is: " << destIP << std::endl;
#
The Power of C++
NeoBASIC code is transpiled into C++, a powerful language that combines high performance, low-level hardware control, and modern object-oriented, generic, and functional programming features, enabling the construction of complex, efficient, and reusable systems. Its ability to directly manipulate memory, combined with a rich standard library and support for high-level abstractions, makes it ideal for both real-time applications (such as games, operating systems, and graphics engines) and high-performance software and embedded systems.
Learn More
Write Once, Run Anywhere
NeoBASIC automatically benefits from C++'s ability to generate executable code for multiple platforms. This offers a significant advantage, as it allows programs written in NeoBASIC to be widely portable, without requiring the transpiler to directly address all the peculiarities of each operating system or architecture. This approach accelerates development, reduces maintenance costs, and facilitates software distribution across heterogeneous environments.
Learn MoreArtificial Intelligence & Scientific Computing
In artificial intelligence and scientific computing applications, where large volumes of data need to be processed with high efficiency and low latency—such as in numerical simulations, machine learning algorithms, or the manipulation of large matrices—C++ enables performance optimizations that higher-level languages rarely achieve. Furthermore, its vast ecosystem of optimized libraries, such as Eigen, Armadillo, dlib, TensorRT, and OpenCV, reinforces its central role in these critical areas.
Learn More
Cross-Platform Game Development
C++ offers an ideal balance between extreme performance and refined control over hardware resources, essential for creating games with complex graphics, real-time physics, and fast responses. Its ability to directly manipulate memory, combined with its efficient use of computational resources, allows developers to maximize the optimization of every aspect of the game, from graphics rendering to artificial intelligence systems. Furthermore, most professional game engines, such as Unreal Engine, CryEngine, Source Engine, and Godot, are written in C++.
Learn More
FinTechs & Algorithmic Trading
Programs written in C++ boast extremely high performance and low latency, crucial features for high-frequency trading systems, real-time risk calculations, and large-scale data analysis. With C++, CPU utilization can be optimized to minimize delays in critical operations such as sending and receiving market orders. Furthermore, its robustness and maturity allow for the construction of complex and reliable systems, with detailed control over every aspect of processing, which is essential in financial environments where accuracy, speed, and stability are paramount.
Learn More
Software as a Service and Cloud Computing
In Cloud Computing, C++ can ensure performance, efficiency, and resource control. Because it's a compiled, low-level language, it allows for the creation of highly optimized services with minimal CPU and memory consumption—essential for scaling applications with reduced operational costs in the cloud. Furthermore, its ability to directly handle networks, files, and protocols makes C++ ideal for building backend services, real-time data processing engines, and critical components in distributed infrastructures.
Learn More
Community
We are a community of developers who love to code.
FAQ
If you can't find your answers here or if you require any further information, feel free to contact us.
Why the name “NeoBASIC”?
The name NeoBASIC is a portmanteau of the terms “Neo” and “BASIC”. BASIC is capitalized because it stands for Beginners' All-Purpose Symbolic Instruction Code. Many versions of BASIC have been created over the years since its creation in 1964, and there has always been a focus on maintaining compatibility with the original language. NeoBASIC uses a new syntax and coding philosophy, primarily to keep pace with the evolution of programming languages since then. Hence the use of the term “Neo” to emphasize a new approach to a language that is easier to learn, more expressive, and geared toward general use.
What is the purpose of creating yet another new programming language?
NeoBASIC's main purpose is to teach programming in a simple and accessible way to students in non-technical fields, such as social sciences and humanities, who do not have a background in advanced mathematics or computer science. NeoBASIC's main guidelines are: (i) To be easy to learn and use, with clear syntax that resembles natural language; (ii) To provide democratic access to programming, especially for beginners and non-specialists; (iii) To serve as an educational tool for introducing programming logic.
What programming languages influenced the syntax of NeoBASIC?
NeoBASIC's syntax was created from languages known for their high productivity and improved development experience (DX), such as Python, Ruby, and Go. Other languages, such as JavaScript, C++, and Haskell, also influenced the syntax. NeoBASIC is intended as an introductory language, designed to facilitate the learner's first exposure to fundamental programming concepts, serving as an accessible bridge to other languages in the future, including even the most complex ones. “Out of many, one language!”
What is the NeoBASIC philosophy that guides its design?
The NeoBASIC language design philosophy revolves around the idea that programmers need peace because programming demands intense mental focus, creativity, and continuous logical reasoning. Besides being an easy-to-learn language, NeoBASIC aims to reduce the mental friction of coding, avoiding frustration and offering a development experience where the programmer feels confident, productive, and in control. NeoBASIC's motto is “Code in peace”, and its mantra is “Write code, one line at a time, and find your peace”.
Is NeoBASIC free?
Yes. NeoBASIC is open source and free, has been free and will always remain free. It is developed under the MIT license, and the source code is available on GitHub.
Are there copyright restrictions on the use of NeoBASIC?
No. The MIT License is recognized as a permissive, widely used, free and open source software license that allows anyone to use, copy, modify, merge, publish, distribute, sublicense, and sell the licensed software without many restrictions. The MIT License imposes no restrictions on the use of the software in proprietary projects, making it very popular for open source projects that seek maximum freedom for developers and companies. There is no problem using NeoBASIC in commercial software, selling it, copying it in source code or binary form (modified or unmodified), or selling products that incorporate NeoBASIC in any way.
Does NeoBASIC have or use a runtime or virtual machine to execute?
NeoBASIC does not require a virtual machine. NeoBASIC programs are transpiled to C++, and when compiled, they are linked with a small runtime support layer. This includes: (i) initialization code (initialization of global variables, static object constructors); (ii) support for features such as exception handling and RTTI (run-time type information); (iii) basic library support (such as handling operators or standard library initialization). This runtime support is minimal compared to other languages like Java or Python.
What are the advantages of transpiling NeoBASIC to C++ and then compiling?
Transpiling to C++ and compiling means using a solid and efficient foundation to ensure portability, performance, and access to a robust ecosystem, facilitating the development and adoption of NeoBASIC. Instead of creating a compiler from scratch for each hardware architecture (such as x86, ARM, etc.), NeoBASIC can build on existing C++ compilers, which are robust, mature, and optimized. This allows NeoBASIC to run on virtually any platform where C++ already works, saving enormous development time and effort. Furthermore, this approach facilitates interoperability. NeoBASIC can easily interact with established C++ libraries and code, which accelerates the development of complex projects, as it is not necessary to reinvent the wheel for features such as graphics, high-performance calculations, or interaction with the operating system.
Who still uses C++?
Lots and lots of companies and government sites. Lots. And if you’re using a compiler or runtime of another language, such as Java, chances are good that it too is implemented in C++. There are too many C++ users to effectively count them, but recent data suggests a figure in the range of 4 to 5 million developers globally. One of the main strengths of C++ is its large community of developers. During 1980-1991, the number of users doubled every seven and a half months. The current growth rate is still steady and positive. Especially since about 2010 there is a renewed growth in C++ as both mobile and datacenter applications value “performance per Watt” as a new mainstream metric. C++ is supported by all major cloud vendors.
Besides C++, are there any plans to transpile NeoBASIC code into other languages?
It's possible because transpilation is done through an open and well-documented API. Initially, the NeoBASIC team will focus on transpilation to C++, but the API allows other developers to create transpilers for other languages. NeoBASIC is intended to be a general-purpose language, and transpilation to other languages can help achieve this goal.
Why is the NeoBASIC community decentralized?
For greater freedom and resilience. Decentralization means anyone is free to create and maintain their own space for NeoBASIC users and developers. There is no concept of “official” or “unofficial” communities—each location has its own moderators and rules. This promotes autonomy, diversity of voice, and prevents the entire ecosystem from being vulnerable to changes or decisions from a single central point. Decentralization helps preserve community continuity even when popular platforms lose reliability or are blocked in a given country.