OSGeo Charter Member · Matrix Chat

Hi! Felipe Matas here.

I've been in open source since 2014. Started with octsympy, moved to sympy, and later (2022) into spatial (R/sf, GDAL, PostGIS, QGIS). My contribution to those larger projects has been mostly reporting and analyzing issues rather than direct commits—learning a codebase takes time I usually don't have, so I put my time where it helps the project most: bugs at the interfaces between abstraction layers, feature requests, and architectural observations. Not all get resolved; feature requests and architectural proposals depend on each project's roadmap.

Issues I've opened, by project:

• sympy — 45
• PostGIS — 23 (OSGeo account required)
• R/sf — 24
• GDAL — 15
• QGIS — 8

When I design something, I think about how it will work at every layer, and I assume the user will try to break it. No solution is perfect, but the tradeoffs should be understood before shipping and in each decision. That's the lens I apply to the projects.

Since 2023 I moved my stack to Rust. In research it solves the performance ceiling I kept hitting with Python. In applied work it saves me time and lets me hand over tools and code that I trust will work.

info_rs — Core project about information: how to store data without losing the interpretation. The concept is applied as a Rust type system for modeling epistemic states of data (censored, unknown, refused, illegible, value, etc.) in surveys and databases. Uses generic enums State<T> and procedural macros (info_macros) to automatically map to PostgreSQL columns. Two implementation iterations included.

build_raw — Code generation tool built with procedural macros. Practical companion to info_rs. Loads any spatial or tabular file into PostgreSQL via GDAL, generates a Rust crate with structs and per-field macros to declare how raw values map to structured State<T> types, and writes the transformed result back as a new table. Production tool used at CIT-UAI.

postgis_rs — Exploration of writing PostGIS extensions in Rust through pgrx and FFI bindings, aimed at contributing to postgis_topology without touching C directly. The geometry_in branch reimplements a core PostGIS parser function in Rust and passes almost all official PostGIS regression tests. Led to a broader architectural conclusion, detailed in the project README.

bevy_wave_equation — Wave equation simulation in Rust with Bevy. Documents the mathematical derivation from discrete springs to the continuous equation, and the concrete challenges of running that math on floating-point hardware: CFL condition, f64 resolution limits, energy conservation as a stability mechanism.

postgis_topology — Code and workflow from my talk at PostGIS Day 2024 (organized by OSGeo). The talk teaches how to use and understand PostGIS Topology, using as an example how to divide administrative territories (communes, provinces, regions) into a topological structure that guarantees no gaps or overlaps between adjacent areas. I also authored the corresponding chapters on the official PostGIS workshop documentation.

camera_rs — Practical Rust application: a real-time V4L2 camera viewer with dynamic controls, built with Bevy and egui using the v4l crate. Producer/consumer threading with Arc<Mutex> for frame extraction. The only project on this list that anyone can clone and use directly.

For 4 years I worked at the Center for Territorial Intelligence (CIT-UAI), an applied spatial research center. Formally an analyst; in practice the person handling problems that needed multiple domains at once—IT infrastructure, production software, technical design and modeling, technology evaluation, keeping the open source stack functional, and consistency across methodologies and requirements. That role naturally acted as a bridge with the open source communities behind the tools we relied on: contributing issues and analyses upstream, always aiming for the best possible outcome on both sides, and keeping a professional separation between the private and the open source layers so neither compromised the other.

I've been playing with Arduino for a long time and learning how computers work at a deeper level. Over the last year, I've been focusing a lot more on OS and HAL topics and their direct application with chips and Verilog. Here are some resources I've found useful:

Operating Systems

• Writing an OS in Rust — The classic tutorial series by Philipp Oppermann. I've read through the early chapters and followed along with the code. It's the most comprehensive guide to building a kernel from scratch, and it's where I'm learning the core concepts. os.phil-opp.com.

Embedded / HAL

• Awesome Embedded Rust — A curated list of embedded Rust projects, crates, and resources. I use it as a reference whenever I'm exploring. rust-embedded/awesome-embedded-rust.
• The Embedded Rust Book — The official guide from the Rust Embedded Working Group. I've read it and used it to understand no_std and embedded-hal. It's essential reading for anyone doing embedded Rust. docs.rust-embedded.org/book.
• Embassy — A modern embedded framework that uses async functions in Rust. I've read through it and understand some of the challenges of running on constrained hardware like Arduino. embassy-rs/embassy.
• AVR-HAL — Rust on AVR microcontrollers (Arduino). I've used it in small experiments. It's impressive that Rust can run on such constrained hardware. Rahix/avr-hal.