ALMaSS has been under continuous development for more than two decades and is used to simulate everything from skylarks and hares to beetles, spiders, newts, roe deer and even people. At its heart sit two components that have remained essentially unchanged in core design since the earliest versions: the landscape simulation and the population managers. The population manager’s job is deceptively simple to state. It holds and manipulates the lists of entities that a particular model focuses on, schedules the actions those agents or population objects perform, and reports the status of the population back to the rest of the simulation. How well it does that job, the new paper argues, shapes the efficiency of the code, the flexibility of the algorithms, and even the outcome of the simulation itself.

The system is written in C++ using a rigorously object-oriented design. All functionality common to every population manager is defined in a base class called Population_Manager, while model-specific details live in descendant classes that inherit that code. A skylark population manager and a ladybird population manager are therefore siblings built from the same skeleton, each tailored with the number and type of life stages, input and output routines, and species-specific behaviours it needs. Inheritance is only the first pillar at work. The design also exploits polymorphism, allowing inherited methods to be re-implemented differently in each descendant, and encapsulation, keeping the internal workings of the class and its data hidden from other parts of the code. The result is a fully functional entity with a clean interface to the rest of the ALMaSS simulation. The class hierarchy can nest several levels deep; for beetles, common routines such as daily day-degree calculations for egg development sit in a general beetle manager, while ladybird-specific reproductive management resides further down the tree.

The core data structure is a list of every individual in the population, organised by life stage. In the original design, all individuals were held in a structure that had to be traversed serially during scheduling, which becomes painfully inefficient when simulations involve many organisms. The current version solves this by splitting the lists into a set of sub-lists, one per thread, in a structure the code calls TheSubArrays. This is a vector of vectors of forward_list: vectors are resizable arrays that can be randomly accessed, allowing the number of lists to be changed at run time to match the number of threads, while a forward_list is a singly-linked container that efficiently accepts new objects pushed onto its end. The first dimension of TheSubArrays represents the types of population entities, typically life stages, which descendant classes can alter. The second dimension is the thread number, enabling parallel running through OpenMP. The third dimension is the list of individuals at each life stage handled by each thread, a list whose length changes constantly as individuals are born and die.

Scheduling is where the design becomes genuinely distinctive. Each simulated time step, usually one day or ten minutes, is divided into what the authors call pseudo time. Before the step begins, three fixed actions occur: the objects of dead individuals from the previous step are deleted and their memory released, the live individuals are distributed evenly across the threads, and every individual is flagged with a variable called StepDone, set to false. The lists are then reordered, typically randomised, so that the order of individuals’ actions cannot bias the outcome. The main scheduling process then runs through three methods: BeginStep, Step and EndStep, each bracketed by a customisable Do method that descendant classes can use for reporting or list management. BeginStep and EndStep iterate through all objects in parallel once each, allowing behaviour to be selected at the start and end of a time step. Step is different: it is called iteratively, in the order of objects in TheSubArrays, until every object signals that StepDone is true. This turns the Step process into a state machine, permitting highly flexible behaviour sets, and an individual can even force another back into the Step code by resetting its flag, an event facility useful for tightly coupled objects such as family groups.

Parallel execution creates a hazard the authors confront head-on: when several agents in the same life stage run simultaneously, two may both try to claim the same resource, such as a patch of food, and both may assume they obtained it, producing serious and hard-to-trace bugs. The solution is a guard map that segments the landscape into non-overlapping grids, each carrying a guard flag. Before an individual performs any location-related activity, it must possess the guard flag for that location; other agents are blocked there until the behaviour completes and the flag is released. In BeginStep and EndStep, which run only a single loop, an agent whose flag is unavailable simply waits and retries later in that section. In the iterative Step function, waiting happens automatically, because the agent can be skipped and called again in the next loop, and loops continue until all individuals report StepDone as true.

To show why execution order matters so much, the authors built a minimalist model called Theoretical1, in which animals compete for a limited food resource. Each individual receives one food unit matched to its needs but forages randomly, gaining between 0.5 and 1.6 units daily, with food translated directly into growth. Each day, an individual selects another at random; if it is twenty percent larger, it can eat that individual and grow by half a percent of the victim’s size. Run for thirty-six months with the before-step action set to do nothing, the fixed execution order handed a decisive advantage to the earliest animals in the list: they grew faster, eventually ate the others, and the population declined while size differences widened. With the order randomised instead, no individual ever gained enough advantage to eat another. Neither version is inherently correct, the authors stress, but the example demonstrates that choosing the wrong representation of execution order can considerably alter a model’s outcome, echoing a concern raised in the literature but rarely quantified.

A second example, drawn from the established skylark model, shows how the three-phase design handles complex behaviour across life stages. Skylarks are territorial, and the insects they forage change daily with vegetation state and weather. Within a single one-day time step, the model must assess food availability around the territory, have the male forage, fill his energetic costs, feed the chicks, then do the same for the female, and finally let chick growth proceed. In the real world these activities are integrated over the day; with a one-day time step that integration is impossible to represent literally. The solution is to order the processes logically so that none depends on a process that follows it. The male’s entire sequence, from assessing forage to allotting portions to each chick, runs in BeginStep, with the forage information communicated to the female. In Step, the female uses that information to determine available forage, subtract her needs and allot food to the chicks. In EndStep, the chicks consume their allotted forage and determine daily growth. Viewed from outside the time step, the behaviour is integrated over the day, exactly as in nature, yet computed efficiently in pseudo time rather than through costly repeated iterations across life stages.

The third example quantifies the payoff of the new multithreading. Theoretical2 creates 10,000 animal objects, each holding 1,000 real numbers, with 1,040 births and 1,000 deaths per time step in a gradually expanding population, and 10,000 squaring calculations per animal per step, run for five simulated years on the same ten by ten kilometre landscape. On a computing node with two Intel Xeon Gold 6130 processors, each supporting 32 threads, run time fell from 443 seconds with one thread to 164 seconds with five, a 63 percent improvement, and further to 103 seconds with forty threads. Gains diminish as thread counts rise, a pattern the authors attribute to synchronisation overheads, and they note that computationally heavier models could benefit more than expected because thread management costs are relatively small. The guard map’s resolution and the complexity of the step code both influence the optimal thread number, so no universal guideline exists. One failure mode remains: the guard map cannot protect a simulation in which an agent can kill another agent of the same type at the same location, as when one adult ladybird eats another, so multithreading must be disabled in such models. Having served for more than twenty years without a major update, the Population_Manager now stands renewed, its authors argue, offering significant speed gains with minimal memory cost, while its central lesson endures: how agents are scheduled should always be an active, deliberate choice, never an accident of code.

Subject of Research: Agent-based population management and scheduling in the ALMaSS simulation framework

Article Title: Managing large and complex population operations with agent-based models: The ALMaSS Population_Manager

Article References: Topping, C. J., & Duan, X. (2024). Managing large and complex population operations with agent-based models: The ALMaSS Population_Manager. Food and Ecological Systems Modelling Journal, 5, Article e117593. https://doi.org/10.3897/fmj.5.117593

Image Credits: AI Generated

DOI: 10.3897/fmj.5.117593

Keywords: ALMaSS, agent-based modelling, population manager, multithreading, ecological modelling, scheduling, OpenMP, simulation software, skylark, C++, Managing, large

OpenMP, short for Open Multi-Processing, is one of the most widely adopted shared-memory parallel programming interfaces in existence. It allows developers writing in C, C++, and Fortran to transform ordinary sequential code into multi-threaded programs by inserting special compiler instructions known as pragmas. A single line such as a parallel for directive tells the compiler to split a computationally intensive loop across many processor cores simultaneously. Used correctly, these directives can accelerate scientific simulations by orders of magnitude. Used incorrectly, they can introduce race conditions, deadlocks, and subtle numerical errors that are notoriously difficult to track down.

The problem, according to the researchers, is that writing correct OpenMP demands deep expertise in parallel programming concepts, data dependencies, and performance optimization strategies, knowledge that general-purpose code models trained on sprawling internet corpora rarely acquire. Existing code generation benchmarks focus overwhelmingly on sequential programming tasks in languages like Python and Java. Curated datasets targeting parallel programming paradigms have been scarce, leaving a critical gap for anyone hoping to build an intelligent assistant for the scientists and engineers who keep supercomputers humming.

To close that gap, the team assembled a corpus of striking scale. Between June and July 2024, they systematically queried the GitHub API for repositories tagged with topics such as high-performance computing, parallel computing, scientific computing, proxy applications, and mini-apps, written primarily in C or C++. They required at least three stars from the community, a signal of validation and active use, and permitted licenses only. The search, executed with a custom Python script that paginated exhaustively through matching repositories, yielded 387 unique repositories.

The raw haul was impressive: 105,861 source files containing more than 22.6 million lines of code, filling 0.71 gigabytes. But the researchers did not simply dump this material into a training pipeline. They subjected it to a multi-stage quality gauntlet. Files that failed UTF-8 encoding validation were discarded to prevent tokenization problems downstream. Files with fewer than 15 tokens, typically containing only boilerplate or comments, were dropped, as were files exceeding one megabyte, which usually turned out to be embedded libraries, generated code, or raw data rather than human-authored source.

The most significant reduction came from deduplication. Duplicate files are rampant across GitHub because of forking, vendored dependencies, and copied implementations, and training a model on redundant examples can bias it toward overrepresented patterns. The team computed SHA-256 hashes of every file using a memory-efficient streaming approach and kept only the first occurrence of identical content. After all filtering steps, the final dataset comprised 77,890 unique source files with 15,367,210 lines of code, a reduction of roughly 18 percent from the initial collection.

The real innovation lies in the annotation. Using a compiled regular expression, the pipeline identified every OpenMP parallel for directive in the corpus, including variants with simd vectorization and reduction clauses. A bracket-matching algorithm then extracted the complete loop structure associated with each pragma, incrementing a counter for each opening brace and decrementing for each closing one until the full loop body was isolated. Comments were stripped from pragma lines to prevent the model from learning spurious comment patterns. Each training sample also includes a configurable window of preceding code context, so the model can learn how variable declarations, array definitions, and computational patterns inform the choice of parallelization strategy.

Special annotation tokens bracket each component, marking loop boundaries and pragma boundaries separately, so a fine-tuned model can clearly distinguish between the code it must generate and the context that conditions its prediction. The captured pragmas span a rich variety of real-world usage: scheduling policies like static, dynamic, and guided; data-sharing clauses such as private, shared, reduction, firstprivate, and lastprivate; synchronization, loop transformations like collapse, thread control, and ordering directives. The simple static-scheduled parallel for appears frequently, reflecting its status as the workhorse pattern for regular, independent loop iterations, while reduction clauses capture numerical computation patterns such as dot products and norm calculations. Source repositories range from linear algebra libraries and geospatial analysis tools to proxy mini-apps that mimic the computational kernels of massive simulations.

The dataset ships in JSON Lines format, with each line a self-contained training sample carrying the source file path for provenance tracking, the extracted pragma, the context length, and the fully annotated sample. The authors recommend a standard causal language modeling protocol with a 512-token maximum length and cross-entropy loss on next-token prediction, evaluating models on the task of generating an appropriate pragma given a code context and loop structure. The format supports streaming processing for memory-constrained environments and parallel loading via line-based sharding, and the researchers advise repository-based train-validation splits to prevent data leakage between related codebases.

The authors are candid about limitations. The dataset covers only C and C++, leaving Fortran OpenMP code unrepresented, and it targets loop-level shared-memory parallelization specifically: directives for GPU offloading, task-based parallelism, standalone vectorization, functional parallelism, and newer OpenMP 5.0 features appear in surrounding context but are not prediction targets. GitHub topic tagging and the mid-2024 collection window introduce further biases, and single-statement loops without braces are currently skipped. Planned extensions aim to broaden directive coverage and explore multi-task learning that selects directive types in addition to generating clauses. Even so, the resource, publicly available on Hugging Face, gives the high-performance computing community something it has long lacked: a rigorous, real-world foundation for building AI that truly understands how parallel code is written.

Subject of Research: A curated OpenMP-annotated code dataset for fine-tuning large language models on parallel programming tasks

Article Title: OpenMP-annotated code dataset for large language model fine-tuning on parallel programming tasks

Article References: Etienne, N., Garcia de Gonzalo, S., & Arnold, D. (2026). OpenMP-annotated code dataset for large language model fine-tuning on parallel programming tasks. Frontiers in High Performance Computing, 4, Article 1771927. https://doi.org/10.3389/fhpcp.2026.1771927

Image Credits: AI Generated

DOI: 10.3389/fhpcp.2026.1771927

Keywords: OpenMP, large language models, high-performance computing, parallel programming, code generation, fine-tuning, dataset, pragma completion, GitHub, C++, scientific computing, OpenMP-annotated

The α phase of FA1-xCsxPbI3 perovskites is crucial because it offers superior optoelectronic properties that translate directly into the performance and lifespan of solar devices. However, conventional two-step fabrication techniques often suffer from poor Cs⁺ incorporation, leading to phase impurities or transitions to less efficient phases. This instability has historically impeded the development of commercially viable solar cells operating under real-world conditions. The innovative strategy introduced by the research team employs an organocaesium compound, caesium 4-(diphenylphosphino)benzoate, as a molecular dopant to facilitate the efficient doping of Cs⁺ ions and achieve an unprecedented homogenization of cation distribution within the perovskite lattice.

This molecular-level precision in doping transforms the perovskite crystallization process, guiding it through a carefully controlled phase transition pathway that stabilizes the α phase. What sets this approach apart is its dual ability to exert nuanced control at the nanoscale while maintaining scalability for manufacturing—a critical factor for practical solar cell production. By modulating the chemical environment during the two-step fabrication, the researchers effectively prevented the formation of non-perovskite phases, preserving the structural integrity and optimal electronic landscape within the film.

The resulting perovskite films exhibited markedly improved morphological uniformity and phase purity, as evidenced by advanced characterization techniques. These high-quality films confer exceptional optoelectronic properties that culminate in solar cell devices exhibiting a record efficiency of 26.91%, standing firm with a certified efficiency of 26.61%. This achievement places these perovskite solar cells among the highest-performing photovoltaic devices reported to date—signaling a pivotal turning point in the field.

Stability, a perennial hurdle for perovskite solar cells, was addressed by incorporating a thermally robust charge-transport layer into the device architecture. Under rigorous testing conditions—continuous 1-sun illumination at maximum power point tracking and elevated temperature of 85°C following the ISOS-L-2 protocol—the devices retained an impressive 95% of their initial efficiency after 1,500 hours. This level of endurance under stress conditions is a compelling testament to the robustness of the doping strategy and the meticulous engineering of device components.

Delving deeper into the fundamental mechanisms, the study elucidates the phase transition pathway of FA0.9Cs0.1PbI3 at a molecular level, unveiling the transition-state structure responsible for the formation of the α phase. Through a combination of experimental and theoretical analyses, the researchers demonstrate how the Cs+ ions stabilize the lattice by suppressing detrimental lattice distortions and phase segregation phenomena. This insight not only elevates our understanding of perovskite chemistry but also provides a blueprint for designing future materials with tailored properties and enhanced stability.

The method opens a new horizon in material science, where controlled ionic incorporation via organometallic intermediates could be leveraged for a broad range of applications beyond photovoltaics. This entails potential impacts on light-emitting diodes, photodetectors, and other optoelectronic devices where phase stability and defect management are paramount concerns.

What makes this work truly compelling is the seamless integration of chemical ingenuity and device engineering. The employment of caesium 4-(diphenylphosphino)benzoate as a dopant is a strategic innovation that represents a departure from traditional halide salt doping methods. This molecular additive not only enhances cation distribution uniformity but also acts as a passivating agent that mitigates trap states—imperfections that typically serve as non-radiative recombination centers reducing device efficiency.

Moreover, the two-step fabrication approach remains compatible with existing manufacturing protocols, ensuring that this advancement can be scaled and adopted within industrial settings without significant overhaul. This pragmatic consideration is essential as the field moves towards commercialization, where cost-effectiveness and reproducibility are as critical as performance metrics.

The implications of achieving such a high certified efficiency alongside operational stability are profound. It suggests that perovskite solar cells could soon rival or even surpass established silicon-based photovoltaics, not only in performance but also in fabrication cost and versatility. The lower material consumption and potential for flexible device architectures align well with emerging energy market demands.

This breakthrough also sheds light on the dynamic and complex nature of perovskite materials, where subtle changes in chemistry and processing conditions ripple through the lattice arrangement, affecting macroscopic device characteristics. The comprehensive understanding gained here serves as a cornerstone for future innovation, guiding researchers in fine-tuning perovskite compositions for bespoke applications.

Importantly, the study’s findings encourage a revisitation of the role of alkali metal dopants in perovskites. Previously viewed primarily as lattice stabilizers, these ions now emerge as active participants in phase transition modulation and defect control. Such revelations fuel optimism for further advancements by exploring diverse organometallic dopants with tailored functionalities.

Equally compelling is the durability aspect. Long-term operational stability remains arguably the most significant barrier before perovskite solar cells become viable on a commercial scale. Demonstrating that device efficiency can be maintained above 95% after 1,500 hours under stress conditions addresses widespread skepticism and provides a tangible benchmark against which future technologies will be measured.

The meticulous research methodology blending synthesis, advanced spectroscopy, microscopy, and computational modeling underscores the interdisciplinary nature of modern materials science. This approach ensures that conclusions are robust and grounded in both empirical evidence and theoretical understanding.

In conclusion, the advent of organocaesium salt-assisted Cs⁺ incorporation offers a game-changing avenue for producing stable, high-efficiency FA–Cs perovskite solar cells. Coupling this with enhanced knowledge of phase transition pathways and the protective architecture of charge-transport layers sets a new standard in perovskite photovoltaics. As this technology edges closer to commercial realization, it heralds a future where clean, affordable, and efficient solar energy is within reach, reshaping the global energy landscape in unprecedented ways.

Subject of Research: Perovskite solar cells; stable α phase formation; cesium ion incorporation; FA1-xCsxPbI3 metal halide perovskites; photovoltaic efficiency enhancement.

Article Title: Controlled Cs⁺ incorporation through organocaesium salts in α-FA–Cs perovskite solar cells with a certified efficiency of 26.61%.

Article References:
He, J., Guo, Z., Liu, K. et al. Controlled Cs⁺ incorporation through organocaesium salts in α-FA–Cs perovskite solar cells with a certified efficiency of 26.61%. Nat Energy (2026). https://doi.org/10.1038/s41560-026-02016-7

Image Credits: AI Generated

DOI: https://doi.org/10.1038/s41560-026-02016-7