How to hire Fortran developers in 2026: A sourcing guide

Fortran is the oldest high-level programming language still in active production use. IBM created it in 1957, and it has been running numerical simulations, weather forecasts, and nuclear physics calculations continuously since then. That is not a historical footnote. ECMWF's Integrated Forecasting System, the most accurate weather model on Earth, is written in Fortran. MCNP, the radiation transport code behind nuclear engineering worldwide, is Fortran. LAPACK, the linear algebra library underneath most scientific computing stacks, is Fortran. These are not museum pieces. They are actively maintained, performance-critical codebases running on the largest machines ever built.

What makes Fortran hiring different from every other language: the people who write it are usually not software engineers. They are physicists, atmospheric scientists, applied mathematicians, and nuclear engineers who happen to write code. They publish papers, not packages. They attend AGU and SC, not developer conferences. Many have never used GitHub and have no presence on any platform a recruiter would normally search. The ones who do use GitHub represent a small but growing community worth understanding. We touched on niche language sourcing in our Rust, Go, and Elixir guide, but Fortran is a different world.

This guide covers where Fortran developers work on GitHub, what separates someone maintaining 1970s-era FORTRAN 77 from someone writing modern parallel Fortran, why the hiring problem gets harder every year, and how to build a sourcing pipeline for a language whose practitioners often do not think of themselves as developers.

The Fortran developer market in 2026

At any given time, roughly 75 to 255 open Fortran positions appear across major job boards. That is not a typo. For a language running on the world's top supercomputers and powering weather prediction for every major country, the job market is vanishingly small. The reason is straightforward: Fortran developers mostly work at organizations that do not post on Indeed or LinkedIn. National laboratories, defense contractors, and government research agencies fill positions through internal networks, academic pipelines, and word of mouth.

The US Department of Energy's national laboratories are the largest employers of Fortran developers in the world. Los Alamos (LANL), Lawrence Livermore (LLNL), Sandia, Oak Ridge (ORNL), and Argonne each maintain millions of lines of Fortran code across dozens of production simulation codes. NASA runs Fortran for orbital mechanics and atmospheric modeling. NOAA's Global Forecast System (GFS) is Fortran. The UK Met Office and ECMWF run their weather models in Fortran. Boeing and Lockheed Martin use it for aerodynamics simulation. These organizations do not hire "Fortran developers." They hire computational physicists, numerical methods specialists, and scientific software engineers who happen to need Fortran.

Compensation varies more by sector than by language proficiency. Mid-level Fortran developers average $82,000 to $102,000. Senior engineers command $120,000 to $160,000. Geophysical specialists working in oil and gas average around $150,000. At the top end, national laboratory scientists can earn up to $301,000 at the highest classification grades, though most positions cluster well below that ceiling. Defense and government-adjacent positions often include security clearances, pensions, and benefits packages that add significant total compensation beyond the base number. Private sector roles in energy, aerospace, and pharmaceutical modeling typically pay higher base salaries but lack the long-term stability that keeps many scientists at national labs for entire careers.

Demographics are the defining constraint of Fortran hiring. The developer population skews older than any other mainstream language. Many of the most experienced Fortran programmers entered the field in the 1970s and 1980s, and retirements are accelerating. LANL published a workforce report noting they are "very likely unable to staff Fortran projects with top-rate computer scientists." New graduates in computational science increasingly learn Python and C++. Some pick up Fortran for specific courses or research projects, but few identify it as a primary language. The pipeline of new Fortran developers is thin, and demand is not falling because the codes they maintain are not being rewritten. Rewriting a 2-million-line nuclear simulation code in C++ or Rust is not a weekend project. It is a decade-long, hundred-million-dollar effort with no guarantee of matching the validated physics. These codes persist because replacing them is harder than maintaining them.

There is a countertrend worth noting. The fortran-lang community, a grassroots effort to modernize the Fortran ecosystem, has gained real traction since 2020. The Fortran Package Manager (fpm) has 929 stars on GitHub. The Fortran standard library (stdlib) is under active development. LFortran, an interactive modern Fortran compiler, has 848 stars and is improving quickly. These projects attract younger developers who see Fortran not as a legacy language but as a tool purpose-built for numerical computing that finally has a modern ecosystem. The community is small, but it is the fastest-growing segment of the Fortran world.

Where Fortran developers contribute on GitHub

GitHub hosts roughly 2,295 repositories tagged with Fortran. That is orders of magnitude smaller than Python or JavaScript, but the repositories that exist carry outsized weight. A single Fortran repository on GitHub might represent a simulation code used by thousands of researchers across dozens of institutions. GitHub-based sourcing works for Fortran, but the context differs from web development languages where repository count correlates with ecosystem size.

The fortran-lang ecosystem. fortran-lang/stdlib is the community-driven Fortran standard library, filling gaps that the language standard itself does not cover: string handling, sorting, file I/O utilities, mathematical functions. fortran-lang/fpm is the Fortran Package Manager, which has done more to modernize the Fortran development experience than any other single project in the last decade. Before fpm, building Fortran projects required hand-written Makefiles or CMake configurations that were hostile to newcomers. Contributors to either repository are actively building the modern Fortran ecosystem and tend to be the most pragmatic, improvement-oriented members of the community.

LFortran. lfortran/lfortran is an interactive, modern Fortran compiler built on LLVM. It supports running Fortran in Jupyter notebooks and compiling to WebAssembly, and it provides developer tooling (error messages, LSP support) that Fortran has historically lacked. LFortran contributors combine compiler engineering with scientific computing, and they represent some of the strongest pure software engineering talent in the Fortran world.

Numerical libraries. Reference-LAPACK/lapack is the reference implementation of the Linear Algebra PACKage, one of the most widely used numerical libraries in existence. Nearly every scientific computing stack, from NumPy to MATLAB, depends on LAPACK. Contributors here understand dense linear algebra at a level few programmers anywhere can match. Other numerical libraries on GitHub include BLAS implementations, sparse solvers, and FFT libraries, all of which draw developers with deep mathematical backgrounds.

Weather and climate codes. Several major weather and climate models have GitHub presences. The Weather Research and Forecasting model (WRF) is one of the most used atmospheric simulation codes in the world. ECMWF has open-sourced components of its forecasting infrastructure, and NOAA maintains public repositories for parts of the GFS. Contributors to these codes are atmospheric scientists and computational fluid dynamics specialists who write Fortran because the models are built in it, and because Fortran's array handling and numerical precision fit the work well.

Physics and engineering simulation. Repositories for molecular dynamics codes (LAMMPS has Fortran components), computational chemistry packages, and finite element solvers appear across GitHub. Many of the largest codes (MCNP, VASP, Gaussian) are not open source and will not show up on GitHub, but smaller tools, preprocessing utilities, and derivative works often do. Developers contributing to open-source Fortran simulation tools frequently also work on the large proprietary codes at their day jobs.

GPU and accelerator computing. CUDA Fortran and OpenACC repositories are at the bleeding edge of Fortran development. HACC, the Hardware/Hybrid Accelerated Cosmology Code, achieved a 300x speedup on the Frontier supercomputer using GPU-accelerated Fortran. Developers working on GPU Fortran understand both numerical methods and hardware architecture. They are some of the most technically deep candidates in any language ecosystem.

Quality signals in Fortran code

Evaluating Fortran code requires different calibration than evaluating web development languages. The gap between "writes Fortran" and "writes good Fortran" often comes down to whether someone learned the language in 1985 and never updated their practices, or whether they know the modern standards and numerical computing best practices. General seniority signals on GitHub still apply, but Fortran has specific markers worth knowing.

Modern vs. legacy style. This is the single most important signal. Fortran has gone through several major standard revisions: FORTRAN 77, Fortran 90/95, Fortran 2003, Fortran 2008, and Fortran 2018. Legacy FORTRAN 77 code uses fixed-form source (columns matter), COMMON blocks for shared data, GOTO statements, implicit typing, and six-character variable name limits. Modern Fortran uses free-form source, modules for encapsulation, derived types for structured data, allocatable arrays, and explicit interfaces. A developer who writes IMPLICIT NONE at the top of every program unit is following modern practice. A developer who relies on implicit typing (where variables starting with I-N are integers) is writing in a style that was already outdated twenty years ago. Both produce correct code, but only the modern style scales to large, maintainable codebases.

Parallelism and HPC patterns. Look for OpenMP directives, MPI calls, and coarray syntax. OpenMP (!$OMP PARALLEL DO) handles shared-memory parallelism on a single node. MPI (MPI_Send, MPI_Recv, MPI_Allreduce) handles distributed-memory parallelism across nodes. Coarrays, introduced in Fortran 2008, provide intrinsic parallel arrays built into the language itself, not bolted on through a library. A developer who uses coarrays understands the Fortran standard at depth and writes genuinely modern parallel code. A developer who combines MPI for inter-node communication with OpenMP for intra-node threading is working at the scale of real supercomputing applications. Both are strong positive signals.

Numerical precision and KIND parameters. Fortran's KIND system lets developers specify exact floating-point precision: REAL(KIND=dp) where dp is defined as a named constant. A developer who hardcodes REAL*8 or DOUBLE PRECISION is using non-portable, legacy syntax. A developer who defines precision constants with SELECTED_REAL_KIND and uses them consistently through the codebase understands numerical stability and portable precision. This matters when code needs to run correctly on different architectures. A small detail, but it separates someone who understands numerical computing from someone who just knows the syntax.

Cache-friendly memory access. Fortran stores arrays in column-major order, the opposite of C. A developer who loops over arrays with the leftmost index varying fastest is writing cache-friendly code. A developer who loops row-first (natural in C) creates cache misses on every iteration, which can cut performance by an order of magnitude in tight numerical loops. This pattern is immediately visible in code and tells you whether someone understands Fortran's memory model or is carrying habits from C.

Module structure and interface design. Well-organized modern Fortran uses modules to group related procedures, types, and constants. Module procedures have explicit interfaces, so the compiler checks argument types at compile time. Code that uses USE, ONLY: to import specific names from modules (rather than pulling in everything) shows the developer thinks about namespace management and code organization. This parallels clean import practices in any language, but in Fortran it is especially telling because the language does not enforce it.

GPU computing. CUDA Fortran (via NVIDIA's compiler) and OpenACC directives are the most advanced tier of Fortran development. These developers write code that runs on GPU accelerators, managing data movement between host and device memory, kernel launch configurations, and parallel reduction patterns. Contributors to GPU-accelerated Fortran codes combine numerical methods, hardware architecture, and parallel programming. They are rare and in high demand.

Testing and documentation. Fortran has historically had weak testing infrastructure compared to Python or JavaScript. Developers who write unit tests (using pFUnit or Fortran's built-in ERROR STOP assertions), maintain test suites, and document their code are showing software engineering habits that are not the norm in the Fortran community. This is a positive signal precisely because it is uncommon. A Fortran developer who also writes tests and documentation has absorbed practices from the broader software engineering world.

Modern Fortran and the HPC ecosystem

The single biggest misconception about Fortran is that it is a dead language kept alive by inertia. The reality is more interesting than that. Fortran is alive because, for a specific class of problems, nothing else matches it. Dense array operations, numerical simulation, high-performance computing at scale: these are what Fortran was designed for, and 69 years of compiler optimization have made it exceptionally good at them. The top three supercomputers in the world (El Capitan at LLNL, Frontier at ORNL, Aurora at Argonne) all run Fortran codes in production. Calling the language dead requires ignoring the largest computers ever built.

Modern Fortran is not your grandfather's FORTRAN. The language has changed substantially since the punched-card era. Fortran 2003 added object-oriented features: type extension, polymorphism, type-bound procedures. Fortran 2008 introduced coarrays, a parallel programming model built directly into the language. Unlike MPI, which is an external library with its own API, coarrays make parallel data distribution a first-class language feature. You declare REAL :: x[*] and the variable is automatically distributed across parallel images. No library calls. No separate communication layer. This is unique among HPC languages and makes Fortran genuinely competitive for new parallel code, not just maintenance of old code. Fortran 2018 added teams, events, and collective operations.

The HPC ecosystem that Fortran operates in determines what kind of developer you are actually hiring. These are the major domains.

Nuclear and particle physics. MCNP (Monte Carlo N-Particle Transport Code), maintained by LANL, is the standard for radiation transport simulation. It is used in nuclear reactor design, medical physics, radiation shielding, and weapons research. MCNP has been in continuous development since 1957 and contains roughly a million lines of Fortran. Developers who work on MCNP typically hold PhDs in nuclear engineering or physics and need Q-level security clearances.

Weather and climate. ECMWF's Integrated Forecasting System (IFS) produces the most accurate medium-range weather forecasts in the world. It is written in Fortran and runs on some of Europe's largest supercomputers. NOAA's GFS, the primary US weather model, is Fortran. WRF, used by researchers and operational forecasters globally, is Fortran. Climate models like CESM (Community Earth System Model) are Fortran. Not a coincidence: weather models solve partial differential equations on massive grids, exactly the kind of dense numerical work Fortran excels at. Developers in this space are typically atmospheric scientists or computational fluid dynamics specialists.

Cosmology and astrophysics. HACC (Hardware/Hybrid Accelerated Cosmology Code) simulated trillions of particles on the Frontier supercomputer, achieving a 300x speedup with GPU-accelerated Fortran. Astrophysics simulation codes for stellar evolution, galaxy formation, and gravitational wave modeling are written in Fortran. These developers bring deep physics knowledge together with extreme-scale computing expertise.

Linear algebra and numerical methods. LAPACK and BLAS sit at the bottom of the stack. When you call numpy.linalg.solve() in Python, you are calling Fortran. Every vendor-optimized math library (Intel MKL, AMD AOCL, ARM Performance Libraries) provides LAPACK and BLAS interfaces. Developers who contribute to reference LAPACK or to vendor-specific implementations understand dense linear algebra at a level that is hard to acquire outside of graduate school.

Aerospace and defense. Boeing, Lockheed Martin, Northrop Grumman, and other defense contractors run computational fluid dynamics (CFD) simulations in Fortran for aircraft design, missile guidance, and structural analysis. These positions almost always require security clearances and US citizenship, further shrinking the already small candidate pool.

Oil and gas. Seismic modeling, reservoir simulation, and geophysical analysis all use Fortran extensively. The energy industry's simulation codes are some of the largest and most computationally demanding Fortran applications outside of government laboratories. Geophysical specialists working with these codes average around $150,000 in compensation.

Understanding these domains matters for sourcing because Fortran developers identify with their domain first and their programming language second. A weather modeler who writes Fortran will respond to outreach about atmospheric science problems, not to a message about "Fortran development opportunities." This is different from, say, a React developer, who is usually hired for framework expertise regardless of the business domain.

How to search for Fortran developers on GitHub

Searching GitHub for Fortran developers means accepting an uncomfortable truth: the best Fortran developers in the world may not be on GitHub at all. Many national laboratory codes live in internal version control systems. Academic researchers often use departmental servers or institutional GitLab instances. The Fortran developers you find on GitHub are a subset, biased toward the community's more software-engineering-oriented members. That said, GitHub is still the best publicly accessible source of evidence about what someone can build. The niche language sourcing strategies from our earlier guide apply here, with Fortran-specific adjustments.

Language filter. Filtering GitHub searches by language:fortran turns up the 2,295 tagged repositories. Because the community is so small, even modest contributions are meaningful. Someone with three Fortran repositories and consistent commit activity over two years is a genuine practitioner, not a hobbyist who tried the language once. Signal-to-noise is high because almost nobody writes Fortran recreationally.

fortran-lang community. The fortran-lang GitHub organization is the center of gravity for modern Fortran development. Start with contributors to fortran-lang/stdlib, fortran-lang/fpm, and lfortran/lfortran. These developers are building the future of the Fortran ecosystem. They skew younger than the average Fortran developer and are more likely to have modern software engineering skills alongside numerical computing expertise. The Fortran Discourse forum (fortran-lang.discourse.group) is the community's primary discussion channel and a good source of contributors who may not have large GitHub profiles.

Conference and publication signals. The Supercomputing conference (SC), the International Supercomputing Conference (ISC), and domain-specific conferences (AGU for earth science, APS for physics) are where Fortran developers present their work. Speaker lists and proceedings are often public. Cross-referencing conference authors with GitHub profiles is labor-intensive but effective, especially for senior candidates who are well-published but may not have an active GitHub presence.

Contribution patterns. Fortran developers on GitHub tend to make fewer but larger commits than web developers. A single commit might represent weeks of work on a numerical algorithm. Do not filter by commit frequency the way you would for a JavaScript developer. Instead, look at the substance: are they adding new physics modules, optimizing numerical kernels, or writing parallel communication code? A Fortran developer with 50 meaningful commits to a simulation code shows more depth than a web developer with 500 dependency bumps.

Adjacent language signals. Fortran developers almost always know C and often know C++. Python is common as a scripting and analysis layer. Look for developers whose GitHub profiles show a mix of Fortran, C, and Python. The Fortran code is the simulation engine, the C code is the interface layer (Fortran-C interop via ISO_C_BINDING is standard practice), and the Python code is the analysis and visualization layer. A developer with all three is a well-rounded scientific computing engineer. For adjacent talent: C++ developers working in scientific computing, computational physicists with Python and MATLAB backgrounds, and Julia developers interested in high-performance numerical work are all viable candidates for Fortran roles given adequate onboarding.

The COBOL parallel. Fortran and COBOL share a structural problem in the hiring market: both have enormous existing codebases, shrinking developer pools, and rewrite costs that exceed maintenance costs. If you are sourcing for both, our COBOL hiring guide covers strategies for legacy language recruitment that transfer directly to Fortran. The key difference is that Fortran has an active modernization effort (modern standards, fpm, LFortran) that COBOL largely lacks, so the talent pipeline, while thin, is not entirely dependent on developers who learned the language decades ago.

A practical Fortran sourcing workflow

Here is what works, from defining the role to first contact.

Step 1: Separate the domain from the language. Before searching for "Fortran developers," determine what you actually need. Is the role primarily about domain expertise (nuclear physics, atmospheric science, computational chemistry) where Fortran happens to be the implementation language? Or is it primarily about software engineering (modernizing a legacy codebase, building CI/CD for Fortran projects, performance optimization) where domain knowledge is secondary? This distinction determines where you search and how you evaluate candidates. A computational physicist who writes Fortran will be found in academic networks and conference proceedings. A software engineer who can modernize Fortran code will be found on GitHub and in HPC engineering communities.

Step 2: Map the relevant codes and repositories. Identify which specific Fortran codes, libraries, or applications are relevant to the work. If you are hiring for weather modeling, the target repositories are WRF, GFS components, and ECMWF open-source tools. If you are hiring for numerical library development, target LAPACK, BLAS implementations, and fortran-lang/stdlib. If you are hiring for Fortran ecosystem tooling, target fpm and LFortran. Each code has its own contributor community, and contributors to one weather model often know the other weather model developers personally. The Fortran world is small enough that mapping the specific code community gets you most of the way to a candidate list.

Step 3: Search GitHub and academic networks simultaneously. GitHub search finds the software-engineering-oriented Fortran developers. For the domain scientists, you need academic channels: Google Scholar for authors on relevant simulation papers, university department pages for postdocs and research scientists, and national laboratory staff directories (many are public). SC and ISC conference proceedings list presenters with institutional affiliations. Cross-referencing these sources with GitHub profiles often reveals developers who have both scientific depth and software engineering capability.

Step 4: Evaluate for modern practices. When reviewing a candidate's code or contributions, look for the quality signals described above: modern Fortran standards (F2003+), explicit typing, module structure, parallel computing patterns (OpenMP, MPI, coarrays), KIND parameters for precision, cache-friendly array access. Seniority signals like code review participation, cross-project contributions, and issue triage are less common in the Fortran world than in web development ecosystems, but when present they are a strong differentiator. A Fortran developer who writes tests, reviews other people's code, and maintains documentation has reached a level of software engineering maturity that is uncommon in the community.

Step 5: Expand to adjacent talent pools. Pure Fortran developers are scarce. Widen the search to include C/C++ developers in scientific computing or HPC, who can pick up Fortran's syntax quickly because the memory model and performance concepts are similar. Computational physicists and applied mathematicians with Python and MATLAB backgrounds understand the numerical methods but need to learn the language. Julia developers are already interested in high-performance numerical computing and their community overlaps significantly with the Fortran modernization effort. PhD students and postdocs in computational science departments may have Fortran exposure from research codes and are approaching the job market. The core insight: Fortran expertise has two components, the language and the domain. Someone with strong domain expertise and adjacent programming skills can learn Fortran far faster than a generalist software engineer can learn atmospheric physics or nuclear engineering.

Step 6: Craft domain-specific outreach. Effective developer outreach is always personalized, but Fortran developers require an extra level of domain specificity. Do not send a message about "exciting Fortran opportunities." Reference the specific problem domain: "We're extending our seismic inversion code to support anisotropic media, and your work on elastic wave propagation in the SPECFEM project caught our attention." Fortran developers, especially those in academic or government positions, care about interesting problems and the ability to work on codes that matter. Many are not motivated by salary alone because their current positions offer stability, pensions, and the chance to work on genuinely important simulations. Your outreach has to compete with the comfort of a national lab position or the intellectual freedom of an academic role. Lead with the problem, not the compensation.

Step 7: Use tooling to cover the GitHub surface. The manual workflow above is necessary for the large portion of Fortran talent not visible on GitHub. For the portion that is visible, tools like riem.ai can automate the discovery step. Describe the role in natural language ("Fortran developers with experience in parallel computing, MPI, and computational fluid dynamics") and get a ranked list of candidates based on actual GitHub contribution data. This is especially useful for finding the younger, more software-engineering-oriented Fortran developers in the fortran-lang community who maintain active GitHub profiles and are more likely to be open to new opportunities than tenured scientists at national labs.

Frequently asked questions

How many Fortran developers are there?

Precise numbers are difficult because Fortran developers rarely self-identify on mainstream developer surveys. GitHub hosts roughly 2,295 repositories tagged with Fortran. The active community concentrates in national laboratories, academic research groups, and defense contractors. A reasonable estimate is tens of thousands of active practitioners globally, with the majority holding PhDs in physics, applied mathematics, or computational science. The population skews older than almost any other language, and retirements are outpacing new entrants. LANL has publicly stated they are "very likely unable to staff Fortran projects with top-rate computer scientists."

What salary should I expect to pay Fortran developers?

In the US, mid-level Fortran developers average $82,000 to $102,000 per year. Senior Fortran engineers command $120,000 to $160,000. Geophysical specialists average around $150,000. National laboratory scientists can earn up to $301,000 at the highest grades. Salaries vary significantly by sector: defense and national lab positions often include security clearances and benefits that add substantial total compensation beyond base salary. The private sector (oil and gas, aerospace, pharma) typically pays more in base salary but may not match the job security and pension benefits of government-adjacent positions.

Is Fortran still relevant in 2026?

Yes. Fortran re-entered the TIOBE top 10 in April 2024 for the first time since 2002. The world's top three supercomputers (El Capitan, Frontier, Aurora) all run Fortran codes. ECMWF's Integrated Forecasting System, the most accurate weather model on Earth, is written in Fortran. MCNP, the radiation transport code used across nuclear engineering, is Fortran. LAPACK, the linear algebra library that underpins most scientific computing, is Fortran. These are not legacy systems waiting to be replaced. They are actively developed, performance-critical codebases where Fortran remains the best tool for the job.

What is modern Fortran and why does it matter for hiring?

Modern Fortran refers to standards from Fortran 2003 onward: object-oriented programming (F2003), coarrays for parallel computing (F2008), and expanded parallelism features (F2018). Coarrays are particularly notable because they provide intrinsic parallel arrays built directly into the language, not added through an external library. A developer who writes modern Fortran with coarrays, derived types, and modules is working in a genuinely competitive HPC language. A developer still writing fixed-form FORTRAN 77 with COMMON blocks may be maintaining legacy code but is not equipped for new development. The distinction matters when screening candidates.

Do Fortran developers need a PhD?

Many positions do require or strongly prefer PhDs, particularly at national laboratories and in computational science roles. This is because Fortran work is almost always tied to domain-specific physics, mathematics, or engineering problems. A Fortran developer working on radiation transport needs to understand neutron physics. A developer working on weather models needs atmospheric science knowledge. However, not all Fortran roles require a PhD. Build system engineers, performance optimization specialists, and developers modernizing legacy codebases can succeed with strong computer science backgrounds and HPC experience. The key is whether the role requires domain science expertise or software engineering expertise applied to scientific codes.

How long does it take to hire a Fortran developer?

Fortran hiring timelines are among the longest in software. National laboratory positions can take 3 to 6 months or more, partly due to security clearance requirements. Private sector roles in oil and gas, aerospace, or pharma typically take 60 to 120 days. The bottleneck is almost entirely candidate supply. The pool of active Fortran developers is small, aging, and concentrated in organizations that offer strong retention (government pensions, interesting problems, job security). Most qualified candidates are not looking for jobs and will not respond to generic outreach. Sourcing from GitHub, academic networks, and conference communities is often the only way to build a pipeline.