The Axiom language is heavily opinionated, so a lot of these features may seem like downsides in other languages. However, each of these features is deliberate. In general, Axiom offers one way to do things rather than giving options. This helps enforce best practices, reduces cognitive load on the programmer, and helps maintain consistency when sharing code.
Specifically, objects are simply maps with with the "class" attribute set, which allows the engine to find the proper context when calling methods.
Having a limited set of types (null, number, boolean, string, array, object) simplifies the language and reduces nuances, which makes the language easier to learn and use.
There are no annotations, decorators, spreads, comprehensions, lambdas, closures, generators, iterators, promises, observables, effects, etc. If you don't know what those are, you don't need to. They are just programmer constructs that are designed to hide/compress code, and often make code much more mysterious, complex, and harder to debug. Because Axiom is designed for simplicity and clarity, it will never support those things. At their worst, advanced/esoteric syntax is often used to cover poor design, which only exacerbates the problem and leads to technical debt.
Axiom does not have exceptions, inheritance, or gotos. I consider all of these to be "convoluting", meaning that they are able to escape traditional block syntax and jump to un-obvious places in the code. Gotos are a way to escape multiple blocks without using break, exceptions are a way to escape multiple blocks without using return, and inheritance is a way to invisibly call/reference code from any other block in the hierarchy (not just outer blocks). All these features lead to spaghetti code, because they cause the flow of execution to jump around without any obvious indicators as to where it will go.
*This is also known as "favor composition over inheritance", which is actually a principle from object-oriented programming (the paradigm which introduced inheritance). The problem, however, is that most programmers coding in object-oriented languages do not follow this principle and end up abusing/overusing inheritance, which leads to poor code and lots of problems. See the Wikipedia article for more details. (Languages like C and Go recognize this issue and do not allow inhertiance, although Go lets you fake it with syntactic sugar/compile-time checks.)
Most languages use a package manager, such as pip for Python, maven for Java, or npm for NodeJS, in order to download code from the Internet and store it to a local cache, because the language itself does not support such code sharing. However, Axiom lets you import code from anywhere on the web simply by passing a url to import(), similar to Deno. This removes the need for a separate package manager or centralized hosting service owned by one entity. Remote imports are cached locally in the folder ".axiom".
For some reason, many high-level programming languages have trouble supporting native threads. Python famously has a "global interpreter lock" that effectively prevents Python code from executing in parallel, NodeJS is just starting to have web workers, and it took years for Java to switch from green to native threads. However, Axiom supports native threads out of the box. Like C++, it is the programmer's responsibility to lock code properly in order to prevent crashes.
Also called a native interface or "foreign function interface" (although kind of a weird name, because the foreign function to a foreign language is often just a native function), this is similar to ffi in MJS, ctypes in Python, and is famously missing from NodeJS as one of the creator's biggest regrets. This allows you to link with external libraries very easily and call native functions without having to do anything special (like write your native code in a certain way or recompile anything).