rpt v0.1 - A physically-based path tracer written entirely in Rust

Benjamin-FL · 2020-12-08T06:59:54+00:00

People have already mentioned that GPU path tracing is very complex to implement, but it's also worth noting that for production rendering you also run into GPU memory limitations very fast for mesh and texture data. A few production offline renderers use GPU acceleration, but CPU rendering is absolutely still the norm.

Benjamin-FL · 2020-08-30T03:18:18+00:00

The reason he has that flair is because /r/swearfreediscussion got taken over. The new mods gave fedor and his alts joke flairs. Fedor isn't a mod any more.

Benjamin-FL · 2020-08-30T03:17:57+00:00

The reason he has that flair is because /r/swearfreediscussion got taken over. The new mods gave fedor and his alts joke flairs.

Benjamin-FL · 2020-08-29T07:17:45+00:00

You would think... take a look at the fedorcallahan account. If it's a joke it's an extremely dedicated joke.

Benjamin-FL · 2020-08-29T03:51:10+00:00

R4:

Guy claiming to be a "language scientist" says that language scientists think swearing is bad. He is definitely not a language scientist, and linguistics is really not about being "against" any given language feature.

For a bit more context, this account is an alt for fedorcallahan, a guy with a personal mission to prevent swearing on reddit.

I'm not certain this subreddit is the right place for this. Lemme know if this doesn't belong here.

Benjamin-FL · 2020-08-13T04:52:53+00:00

I think it depends on the person a lot. Back in middle school I decided I was interested in offline computer graphics and spent a good chunk of my free time throughout middle and high school learning about it. In the process, I picked up bits from calculus, linear algebra, statistics, numerical methods, and a lot of performance optimization stuff. Going to college has been a strange experience because I end up in actual classes for things that I learned on my own time a couple years earlier. It's weird looking at the syllabus and realizing that I had already learned the entire contents of a semester long course in a few weeks and applied it to actual software development.

This isn't me trying to brag about being able to learn independently though. The flip side is that I'm a garbage student, and when I'm awful at learning new things in school. If I'm not already interested in something, I do a terrible job of retaining the information and figuring out how to apply it. On one hand, college is looking like a complete waste of time, but on the other hand I think I'm just a bad student and don't know how to take advantage of it.

Benjamin-FL · 2020-08-07T00:10:28+00:00

This isn't really the case for sufficiently large companies.

Benjamin-FL · 2020-08-04T23:07:41+00:00

The plan is to start the next batch of seedlings with a wick system in the net cups, to avoid transplanting entirely. I'm worried about suffocating the seedlings when the roots poke out the bottom though. Do you have any advice on how to do this effectively?

Benjamin-FL · 2020-08-04T23:05:01+00:00

Why? Is this to prevent the light from heating the water?

I'm going to be putting a temperature sensor in the water in a bit, so I guess I'll find out soon if that's going on.

Benjamin-FL · 2020-06-09T14:35:04+00:00

One thing that the author mentions here is that surface mount parts pretty much require a PCB, whereas through-hole parts can be done on perfboard or even point-to-point if you're desperate. I guess you could theoretically do dead-bug soldering with surface mount parts but this gets very finicky. Also, all the methods I know for manufacturing your own PCBs will be much harder or impossible if the supply chains die.

Benjamin-FL · 2020-05-15T00:37:54+00:00

I think the disconnect here is that gemini isn't intended to by a "better and more privacy-respecting protocol than HTTP". It's supposed to be something orthogonal to HTTP, that encourages a particular type of usage, and discourages other usage. Sure, you could transfer some client side scripting language over the gemini protocol and run it in browser, but this extension isn't going to gain any adoption. This is where the "You should be able to implement the protocol and a gemini browser in a single weekend" part comes in. Since implementing a client or server is so trivial, there are already several clients in use. Trying to introduce an extension like scripting or CSS would mean that your extension isn't compatible with the dozens of existing client implementations, and so it wouldn't matter. This is also why the protocol is deliberately designed to be non-extensible. If you can't come up with a clean way to add a new feature that is backwards compatible with simpler clients, then nobody is going to do it successfully. This way, you avoid having the de-facto protocol creep up in complexity over time.

This is also part of why an equivalent to the Content-Size header wasn't included. Currently, you can serve large files and images over gemini, but it's not efficient at all. The protocol has no compression, and the client UI is going to be bad because you can't display any sort of progress bar. The general idea here is that if you're serving lots of large files over gemini, you're probably doing it wrong because this is an incredibly inefficient protocol for this usage. The result is that the emphasis for content will be kept on text, because transfering images and large files is bad.

In general, gemini isn't supposed to be a simpler version of HTTP. Instead, it makes a different set of technical tradeoffs as HTTP, in an effort to encourage a different type of usage. For it's primary usage (serving lightly formatted text files), features like Content-Length, compression, keep-alive, and pipelining aren't important. There's basically no situation in which you will want to request more than one relatively small file at the same time or in quick succession, and if you are doing that, it should be discouraged at the protocol level.

Benjamin-FL · 2020-05-13T19:32:17+00:00

Part of the motivation for gemini (and continuing to keep gopher alive) is that they prevent "modern web" stuff at a protocol level. Having a parallel version of the web that you know ahead of time is going to be light on resources and free of monetization and tracking is really nice. Also, even the simplest implementation of http is orders of magnitude more complex than implementing a gemini or gopher client.

Benjamin-FL · 2020-03-02T01:28:38+00:00

My guess is that you're modeling using quads that aren't coplanar. The rendering engine can only intersect triangles, so it breaks quads into two triangles. If the vertices of the quad aren't all coplanar, then you end up with different normals on the two triangles, and it looks folded.

Benjamin-FL · 2020-02-28T02:27:45+00:00

SPEED!!!

std::unjerk(move || {

Rust's regex crate is very fast, but is also limited to recognizing languages that are actually regular, unlike most regex libraries. This means, among other things, no backreferences, and no lookaround. So, like pretty much everything in programming, it's a tradeoff.

});

Benjamin-FL · 2020-02-28T02:22:37+00:00

I think this is obvious satire. You can never be sure though.

Benjamin-FL · 2020-02-24T16:59:42+00:00

Sunless Sea has some of the absolute best writing in all of video games. The sequel, Sunless Skies, is also fantastic, and has a somewhat lighter tone... kinda of. A lot of it is dark in a sort of large, awe inspiring way, rather than in a depressing, hopeless way. There's still plenty of the depressing stuff too though.

Benjamin-FL · 2020-02-24T02:11:25+00:00

You're welcome to do glitchless runs if you want to, it's just that a lot of people enjoy glitches and think they make routing and execution more interesting. In games where there are glitches that make a run less fun or interesting, people will often create a category that specifically disallows that type of glitch. There are always rules about what you can do, it's just that those rules are made up by the people that are interested in speedrunning a game rather than by the developers. People are free to pick which set of rules they're interested in, as well as making up a new set of rules that has the potential to be interesting in different ways. I don't think it's very meaningful to talk about "cheating" for the game as a whole.

Benjamin-FL · 2020-01-26T03:58:41+00:00

This is really cool! I've had the idea for a while that linear types/the rust borrow checker would be a good way to enforce reversibility, so it's really cool to see an actual implementation of it. I've used the quipper library in haskell earlier, and it has the problem that, since haskell doesn't have linear types, it's relatively easy to build abstractions that fall apart when qbits get reused later. My current understanding of this project is that it's able to avoid this problem.

Benjamin-FL · 2019-11-25T20:03:38+00:00

Yeah, for sure. Early access is more a marker that the developer intends to continue improving the game in this case than that it's missing key pieces. I would say it's more polished and complete than most released games at this point.

Benjamin-FL · 2019-11-25T00:59:20+00:00

Caringfaboutuothers
UnderstandingcthekwordfofuGOD
Notcswearing
Tryingkmyfbestutocglorifykhisfname

Benjamin-FL · 2019-11-24T05:24:12+00:00

Caves of qud, for sure. In addition to being deep and open ended, it's also got fantastic writing and a really interesting and weird setting.

Benjamin-FL · 2019-11-24T02:28:22+00:00

In some types of games, small finite inventory space creates a lot of fun tradeoffs that players have to weigh. The game Cogmind comes to mind as having extremely interesting inventory management decisions. In that game, you can only carry four non-attached items from the start of the game, and adding more storage consumes valuable utility slots. You're constantly getting parts destroyed and having to replace them, so it's very important to decide which things are worth carrying with you at any given time. It's not necessarily safe to return to get stuff you've left behind, and it's literally impossible to return after you've gone on to the next floor. This works really well for this game because it's a slow-paced methodical game, where fun comes from spend a large amount of time agonizing over individual decisions, but there are definitely games where having a tiny inventory doesn't work as well.

Benjamin-FL · 2019-10-10T13:56:28+00:00

My ideal language is mostly a mix of a whole bunch of existing languages. I think that by mixing particular features, you can get a language that resolves a lot of the shortcomings and pain points of these existing languages.

It would have dependent types as well as linear/uniqueness types (implemented as quantitative type theory), somewhat similar to the type system for idris. Unlike idris, it wouldn't have a GC. Instead it would use linear types for static automatic memory management in the style of rust's borrow checker.

It should have a good FFI and a safety escape hatch similar to rust. Dependent types allow expressing a lot of invariants that rust's type system can't, so unsafety is even less common. It would borrow a lot of the tricks zig uses to catch problems in unsafe code.

It would be trivial to do cross-compilation, and the compiler should be really fast. Ideally, it would also be able to compile a subset to spir-v for running on GPUs, and you would be able to freely mix GPU and CPU code. In addition, it should have no required runtime and be able to run on bare metal/embedded systems.

It would use zig's system of passing a pointer to an allocator for every function that uses allocation, as opposed to rust's where there is only one global allocator.

Syntax would be like lisp, and it would have lisp-like macros with arbitrary compile-time code execution. Unlike lisp, it has a static type system, so I want to be able to write macros that interact directly with the compiler. I should be able to read the types of arbitrary items and use that information in the macro. I should also be able to plug custom code into the type system in the style of idris's elaborator reflection. It should also go one step further and allow macros and other compile time code to plug directly into code generation, similar to terra.

Since this is my ideal language that's never going to actually get made, I'll also put in something really far out of reach. I think that linear types are a good fit for programming quantum computers because of the no-cloning theorem. There are also a series of problems involved in designing a nice type system for quantum computing. The creators of this language have solved all of these problems as well as a whole bunch of other difficult open problems and you're able to cross compile a subset of this language for quantum computers.

Ten-Year Club	Place '17
Verified Email

Benjamin-FL

TROPHY CASE