Nimporter is a library that allows you to directly import Nim modules as if they were Python code.

https://github.com/Pebaz/nimporter

After 2 months of hard work, I am proud to announce the release of Nimporter version 1.0.0! I have now implemented all of features necessary to consider Nimporter complete but will continue to provide bug fixes and small enhancements as they become necessary. The greatest feature in this release is the ability to distribute libraries using Nim code without requiring the end user to install a Nim compiler. Here is a list of the new features introduced in this version:

• Distribute libraries with Nim code without requiring end users to install a Nim compiler!

• Much easier installation: pip install nimporter.

• Nimporter can work with Nim installed via Choosenim or manually.

• Nimporter finds Nim standard library automatically.

• Entire Nim projects with .nimble dependencies are now officially supported.

• Binary (wheel) distributions are officially supported and are effortless to create (1 extra line of code).

• Source distributions now directly imply that they contain bundled Nim source files.

• Absolute control over CLI args are 100% supported for an arbitrary number of platforms and situations.

• Arbitrarily complex namespacing is maintained for libraries packaged with Nim code.

• 44 unit tests and 5 integration tests.

• 94% code coverage

• Official Nimporter CLI for cleaning cached builds and compiling extensions in the terminal.

• Generated documentation.

• New logo. 😃

There is now no excuse not to make your Python code more performant using Nim. All of the hard work has been done for you: simply plop a Nim source file into your project, import nimporter, and then directly import your Nim code. You can now think of Nimporter as Cython for Nim, but seamless.

Furthermore, none of your end users have to install a Nim compiler (or a C compiler for that matter). Distribution is 1 extra line of code.

Using Nim with Python now involves the same effort as writing pure Python.

Welcome to Nimporter 1.0.0.

Hey all, I've been working on a terminal emulator for some time. It's called Nitty.

It uses the [surfer](https://github.com/nim-windowing/surfer) library under the hood, making it Wayland-native (and for now, Wayland-only).

It's tiny (~1200 LoC) and efficient (~0.6%-0.9% CPU usage while idling), and is smooth from my personal usage.

It uses an OpenGL (ES) renderer (NanoVG) and uses caching and damage tracking to avoid rendering the entire terminal grid every single frame.

It can be configured using TOML, but there's a lot to be desired here, especially documentation. Contributions are welcome here. :P

It also supports and utilizes fractional scaling, cursor shaping and the system bell protocols when possible and required.

Nowadays, I daily drive it instead of WezTerm, but that's largely because my usecases are very basic and simple (Neovim, some terminal programs, etc.).

[Source Code](https://github.com/xTrayambak/nitty)

https://plugins.jetbrains.com/plugin/15128-nim

Nim has made me passionate about programming again.

I've tried:

• Java

• C

• C#

• C++

• Python

• R

• Haskell

• Octave

• Scala

• Kotlin

• ...

My favorite languages have been Python and R, but I've grown to dislike them due to them not really being general or system technologies. But I've always liked Python for how it allows the kind of abstraction that one needs. For example, if one doesn't need classes, then one's not required to use classes. I liked Kotlin as a language, but not because of JVM. C# was also okay, but not because of .Net. I liked Java for being trustworthy to compile, but not because of the language being messy for things for which its OO is not a very good fit, such as numerical algorithms. In particular, Java programs are hard to read, when its class model does not fit the problem very well. Never liked C++ because of the absurd amount of manual management it requires. Without a good framework, it feels like cleaning a pile of garbage all the time. Only liked C, because it's historically so crucial.

But I have been playing with Nim for a few weeks. I get the kind of warm feeling that I got when I started with Python. It's fun to use, it makes programming feel pleasurable, rather than painful. It lets me focus on the ideas and not the management of compilation toolchains, language gotchas, etc. It's also interesting that it feels like one's getting a lot of the features of other languages in one language so that one can decide e.g. between using GC and not using GC.

Yesterday, I released my first commercial game, The Long Arc, for the Playdate console. I’ve been working with Nim for 10 years, so it was an obvious and early choice for me, despite the Playdate SDK being designed for C and Lua.

The biggest technical hurdle was managing memory ownership between Nim and Playdate’s C libraries. The challenge was figuring out clear memory ownership rules when working across FFI boundaries. Some Playdate APIs expect you to manage allocations manually, while others manage it for you. Unfortunately, it wasn’t always clear from the documentation. Debugging these cases took time and was the biggest source of crashes the whole project.

I also wrote my own ECS (https://github.com/NecsusECS/Necsus) library for this project. It took a lot of time, but I don’t regret it—I learned a ton about how games work under the hood, and the end result was lightweight and well-suited to my needs.

Overall, I just wanted to share how pleased I am to have finished, and that Nim was the right choice for me.

Cheers!

Since it just so happens that Nim in Action is book of the day today, I figured I'd create an AMA for fun.

I've been involved with Nim since 2009 and over the years I have implemented everything from web frameworks, IDEs to multiple modules in Nim's standard library and many other things.

I have also written the first book on Nim, Nim in Action, which you can learn more about on its website: https://book.picheta.me/. You can also find a 50% off promo code there :)

Happy to answer any questions, about Nim or otherwise. AMA

Edit: 22:47 BST. I'll be heading to bed, but will answer any more questions tomorrow morning, so keep them coming!

Edit: thanks for the awesome questions! Hope you enjoyed the answers :)

See here: https://www.youtube.com/watch?v=WHyOHQ_GkNo . Made by Fireship.

Hello Nimmers,

I started learning Nim (almost exactly) 2 months ago, and began by writing a window manager. Today, I released the beta version of Nimdow!

The intent of the release is to find and iron out bugs. Although, I've been using Nimdow for about a month now and haven't had many issues, so it should be usable for most people. Bug reports and general feedback are very welcome.

I just wanted to say thanks to the awesome community for making this experience a good one. Nim is a great language, and almost as good as the people.