kurbo
Odin
kurbo | Odin | |
---|---|---|
5 | 86 | |
650 | 5,792 | |
3.4% | 5.1% | |
7.8 | 10.0 | |
18 days ago | 6 days ago | |
Rust | Odin | |
Apache License 2.0 | BSD 3-clause "New" or "Revised" License |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
kurbo
-
Voronoi Diagram and Delaunay Triangulation in O(nlog(n)) (2020)
The numerical robustness thing gave me a chuckle (rotate 1 radian and pray to the geometry gods), especially as I've been spending a good fraction of my time dealing with that in fancy path rendering and stroking.
One of the things I really want to work on in the next few months is a path intersection implementation that's robust by construction, backed up both by a convincing (if not formal) argument and tests crafted to shake out robustness issues. I have a bunch of ideas, largely motivated by the need to generalize well to curves - Shewchuk's work, cited elsethread, is impressive but I'm not smart enough to figure out how to make it work for arbitrary Béziers.
There's an issue[277] to track the work, and that has pointers to some of the ideas. If anyone is interested in working with me on this, please get in touch. If successful, I think it'll result in a nice code base and also likely a publishable paper.
[277]: https://github.com/linebender/kurbo/issues/277
-
Announcing Bezier-rs: computational geometry algorithms for Bézier paths (seeking code review and boolean ops help)
I have some ideas on how to do boolean ops, some of which is written up in a blog post issue, and for which I have some code locally. In particular, the parabola estimate seems much more efficient than the usual fat line approach. I also have a sketch of quadratic/quadratic intersection in kurbo#230.
-
Bit Twiddling Hacks (2005)
I love these kinds of things and use them in GPU programming, among other things. Things have changed in a variety of ways: population count and count-trailing-zeros are generally available as fast instructions now. Multiply is also now just as fast as other operations, so is not to be avoided.
A couple examples. [1] computes the sum of the number of bytes used of four consecutive segments of a bezier path - each segment can be lineto, quadto, or curveto, can be the end of a path or not, and be i16 or f32. 4 tag bytes are packed into a 32 bit word, it computes all these, then sums them together.
[2] linearizes a recursive subdivision into an iterative loop. The stack depth is represented as the number of zeros in a word, so pushing the stack is a left shift, and popping is a right shift. It turns out you want to pop multiple levels at once, and the number of levels is computed by countTrailingZeros. ([2] is experimental Rust code, but I will adapt this into a compute shader)
[1]: https://github.com/linebender/piet-gpu/blob/main/piet-wgsl/s...
[2]: https://github.com/linebender/kurbo/blob/euler/src/euler.rs#...
-
A Review of the Odin Programming Language
That's a reasonable choice and I do agree it has nice properties, for example (a << b) << c is equal to a << (b + c) (unless that latter addition overflows), but it also does put you pretty firmly in the category of "not squeezing out every last cycle like you can in C." Usually that's one of the the things people expect in a tradeoff involving safety.
Regarding "never," I am an adventurous programmer[1], so am fully willing to accept that I am the exception that proves the rule.
On the more general point of UB for arithmetic overflow, I think we're on the same side: this is a pretty broken story in the way C has ended up, and one of the clear motivations for a cleaned up better-than-C language. I'm more interested in your thoughts on data races, where I suspect we have a substantive difference in perspective.
[1]: https://github.com/linebender/kurbo/blob/de52170e084cf658a2a...
- Kurbo: A Rust library for manipulating curves
Odin
-
Giving Odin Vision
This article is about my experience with Odin programming language. So, I won't talk about its features and advantages and provide basic tutorials. There are plenty of materials on those topics.
-
Zig, Rust, and Other Languages
There's also Odin[0] too. I tried using them all and Odin was pretty nice. Nim is also good too but a lot more features.
But - I concluded that language matters a lot less compared to APIs. Yes, the language should have enough good features to let the programmers express themselves, but overall well designed APIs matter a lot more than language. For example -tossing most of the C stdlib and following a consistent coding style (similar to one described here -[1]), with using Arenas for memory allocation, I can be just as productive in C.
[0] - https://odin-lang.org
-
Odin Programming Language
I highly recommend looking at:
* The Overview: <https://odin-lang.org/docs/overview/>
* examples/demo: <https://github.com/odin-lang/Odin/blob/master/examples/demo/...>
As for the first example: a basic lexing example is probably boring, but it does show some basic ideas of what the language is about. If people want to write better examples or just reorder the current ones, please feel free to make an issue or PR on the website's GitHub page: <https://github.com/odin-lang/odin-lang.org>.
-
babel tree
I use Odin primarily, it’s C-level but pascal/Go syntax and inspiration https://odin-lang.org/
- Botlib: Telegram Bots in C by Antirez
- "Odin is a general-purpose programming language with distinct typing built for high performance, modern systems and data-oriented programming."
- Austral Programming Language
- Small Joys with Odin
-
Can't decide what engine/library/framework I want to master
Website: https://odin-lang.org/
-
Download Odin and get started today! Includes binding to popular video game libraries
Get it from the website: https://odin-lang.org/ -- Odin includes bindings to popular gamedev libraries & APIs such as Raylib, SDL, DirectX, OpenGL and Vulkan.
What are some alternatives?
geogram - a programming library with geometric algorithms
zig - General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.
v - Simple, fast, safe, compiled language for developing maintainable software. Compiles itself in <1s with zero library dependencies. Supports automatic C => V translation. https://vlang.io
Nim - Nim is a statically typed compiled systems programming language. It combines successful concepts from mature languages like Python, Ada and Modula. Its design focuses on efficiency, expressiveness, and elegance (in that order of priority).
rust - Empowering everyone to build reliable and efficient software.
carbon-lang - Carbon Language's main repository: documents, design, implementation, and related tools. (NOTE: Carbon Language is experimental; see README)
Beef - Beef Programming Language
bevy - A refreshingly simple data-driven game engine built in Rust
Jai-Community-Library - Tutorials and Cheatsheet for Jai, written by its community
crystal - The Crystal Programming Language
red - Red is a next-generation programming language strongly inspired by Rebol, but with a broader field of usage thanks to its native-code compiler, from system programming to high-level scripting and cross-platform reactive GUI, while providing modern support for concurrency, all in a zero-install, zero-config, single ~1MB file!
TinyGo - Go compiler for small places. Microcontrollers, WebAssembly (WASM/WASI), and command-line tools. Based on LLVM.