Update for more of a research focus

docs/assets/code/c/src/MainReactor.lf

@@ -0,0 +1,34 @@
+target C
+reactor ReactorA {
+  output output_port: int
+  @label("timer (offset, period)")
+  timer t(0, 100 ms)
+  @label("reaction A1")
+  reaction(t) -> output_port {=
+  =}
+}
+reactor ReactorB {
+  input input_port: int
+  output output_port: int
+  @label("reaction B1")
+  reaction(input_port) -> output_port {=
+  =}
+}
+reactor ReactorC {
+  input input_port1: int
+  input input_port2: int
+  @label("reaction C1")
+  reaction(input_port1) {=
+  =}
+  @label("reaction C2")
+  reaction(input_port2) {=
+  =}
+}
+main reactor {
+  a = new ReactorA()
+  b = new ReactorB()
+  c = new ReactorC()
+  a.output_port -> c.input_port2 after 200 ms
+  a.output_port -> b.input_port after 100 ms
+  b.output_port -> c.input_port1 after 100 ms
+}

docs/developer/downloading-and-building.mdx

@@ -41,7 +41,7 @@ For more details on our testing infrastructure, please refer to the [Regression
 If you only want to build without running any tests, you can use `./gradlew assemble` instead.
 Both the assemble and the build task will create a distribution package containing our command line tools in `build/distribution`.
 There is also an installed version of this package in `build/install/lf-cli/`.
-If you run `build/install/lf-cli/bin/lfc` this will run lfc as it was last build.
+If you run `build/install/lf-cli/bin/lfc` this will run lfc as it was last built.
 Thus, you can choose if you want to use `bin/lfc-dev`, which first builds `lfc` using the latest code and then runs it, or if you prefer to run `./gradlew build` and then separately invoke `build/install/lf-cli/bin/lfc`.
 
 ## IDE Integration

docs/installation.md

@@ -8,7 +8,7 @@ The Lingua Franca toolchain requires Java 17 ([download from Oracle](https://www
 
 You can use Lingua Franca:
 
-- [in Visual Studio Code, using our extension](#visual-studio-code)
+- [in Visual Studio Code and compatible tools, using our extension](#visual-studio-code)
 - [using the command line](#cli-tools)
 
 You can also spin up one of our pre-configured Cloud-based dev environments:
@@ -17,11 +17,11 @@ You can also spin up one of our pre-configured Cloud-based dev environments:
 
 [![GH Codespace](https://github.com/codespaces/badge.svg)](<https://github.com/codespaces/new?hide_repo_select=true&repo=477928779&ref=main&skip_quickstart=true&devcontainer_path=.devcontainer%2Fnightly%2Fdevcontainer.json>)
 
-Have a look at the [Lingua Franca playground](https://github.com/lf-lang/playground-lingua-franca) for more details.
+Have a look at the [Lingua Franca playground](https://github.com/lf-lang/playground-lingua-franca) for example programs and more details on the cloud-based dev environments.
 
 ## Visual Studio Code
 
-Our Visual Studio Code extension can be installed via the Marketplace or built from source, as detailed below. See the [handbook](./tools/code-extension.mdx) for usage instructions.
+Our Visual Studio Code extension can be installed via the Marketplace or built from source, as detailed below. This extension also works with VS Code-compatible tools such as [Cursor](https://cursor.com). See the [handbook](./tools/code-extension.mdx) for usage instructions.
 
 ### Marketplace
 
@@ -37,6 +37,13 @@ Alternatively, you can run the following command in your terminal:
 code --install-extension lf-lang.vscode-lingua-franca
 ```
 
+or
+
+```
+cursor --install-extension lf-lang.vscode-lingua-franca
+```
+
+
 To use the nightly pre-release of the extension instead of the latest release, find the Lingua Franca extension in the Extensions tab and click on the "Switch to Pre-Release Version" button.
 
 ### From Source
@@ -56,6 +63,13 @@ Run the following command in your terminal to install the latest release (on Win
 curl -Ls https://install.lf-lang.org | bash -s cli
 ```
 
+If you get `permission denied`, your platform may require `sudo`, as follows:
+
+```
+curl -Ls https://install.lf-lang.org | sudo bash -s cli
+```
+
+
 You can also install the nightly pre-release:
 
 ```
@@ -80,9 +94,7 @@ yay -S lf-cli-nightly-bin
 
 ### Nix and NixOS
 
-The Lingua Franca compiler is packaged in [nixpkgs](https://github.com/NixOS/nixpkgs/blob/nixos-23.11/pkgs/development/compilers/lingua-franca/default.nix#L28) and is available via the binary cache.
-
-Run
+The Lingua Franca compiler is packaged in [nixpkgs](https://github.com/NixOS/nixpkgs/blob/nixos-23.11/pkgs/development/compilers/lingua-franca/default.nix#L28) and is available via the binary cache. Run
 ```
  nix shell nixpkgs#lingua-franca
 ```

docs/introduction.md

@@ -6,23 +6,36 @@ slug: /
 
 Lingua Franca (LF) is a polyglot coordination language built to enrich mainstream target programming languages (currently C, C++, Python, TypeScript, and Rust) with deterministic reactive concurrency and the ability to specify timed behavior. LF is supported by a runtime system that is capable of concurrent and distributed execution of reactive programs that are deployable on the Cloud, the Edge, and even on bare-iron embedded platforms.
 
-A Lingua Franca program specifies the interactions between components called reactors. The logic of each reactor is written in plain target code. A code generator synthesizes one or more programs in the target language, which are then compiled using standard tool chains. If the application has exploitable parallelism, then it executes transparently on multiple cores without compromising determinacy. A distributed application translates into multiple programs and scripts to launch those programs on distributed machines. The communication fabric connecting components is synthesized as part of the programs.
+As you build your programs, the tools automatically generate interactive diagrams that show the components of your program. For example:
+
+import RegressionTestSVG from "./assets/images/diagrams/MainReactor.svg"
+
+<RegressionTestSVG title="Lingua Franca diagram: RegressionTest" role="img" width="700" />
+
+A Lingua Franca program specifies the interactions between concurrent components called reactors. There are three reactors above. Each reactor contains one or more reactions, which specify code (in C, C++, Python, Rust, or TypeScript) to execute when triggered by events. Events come from timers (periodic and aperiodic), input ports, or from the environment.
+
+If the application has exploitable parallelism, then it executes transparently on multiple cores or multiple machines without compromising determinacy. The above program shows a simple pipeline chain, where reactions A1, B1, and the reactions in C all can execute in parallel. The logical delays of 100 ms on connections between ports enable such parallel execution. In ReactorC, reactions C1 and C2 do not execute in parallel because they (potentially) share state variables. The deterministic semantics of LF ensures that for the above program, reaction C1 will always process the previous result of B1 (not the one being computed in parallel), which is triggered by the 200ms-old result from A1. Only after reaction C1 completes, reaction C2 will process the 200ms-old result from A1. Hence, despite the parallel execution, and even if this program is distributed across networked hosts, the computation is deterministic and repeatable.
+
+The `lfc` code generator synthesizes one or more programs in the target language, which are then compiled using standard tool chains. A distributed (federated) application translates into multiple programs and scripts to launch those programs on distributed machines. The communication fabric connecting components is synthesized as part of the programs.
+
 
 ## Reactor-Oriented Programming
-Lingua Franca programs are compositions of reactors, which are stateful
-components with event-triggered routines that may read inputs, write outputs, manipulate the reactor's state and schedule future events. 
-Reactors are similar to actors, software components that send each other messages, but unlike classical actors, messages are timestamped, and concurrent composition of reactors is deterministic by default. When nondeterministic interactions are tolerable or desired, they must be explicitly coded. LF itself is a polyglot composition language, not a complete programming language. LF describes the interfaces and composition of reactors. See our [publications and presentations](/research) on reactors and Lingua Franca.
+Reactors are stateful components with event-triggered routines that may read inputs, write outputs, manipulate the reactor's state and schedule future events. 
+Reactors are similar to actors, software components that send each other messages, but unlike classical actors, messages are timestamped, and concurrent composition of reactors is deterministic by default. When nondeterministic interactions are tolerable or desired, they must be explicitly coded.
+
+LF itself is a polyglot composition language, not a complete programming language. LF describes the interfaces and composition of reactors. See our [publications and presentations](/research) on reactors and Lingua Franca.
 
 The reactor-oriented programming paradigm is informally described via the following principles:
 
-1. _Components_ — Reactors can have input ports, actions, and timers, all of which are triggers. They can also have output ports, local state, parameters, and an ordered list of reactions.
+1. _Components_ — Reactors can have input ports, actions, and timers, all of which are triggers. Actions are used to schedule irregular (non-periodic) events, whereas timers specify periodic events. Reactors can also have output ports, local state, parameters, and an ordered list of reactions.
 2. _Composition_ — A reactor may contain other reactors and manage their connections. The connections define the flow of messages, and two reactors can be connected if they are contained by the same reactor or one is directly contained in the other (i.e., connections span at most one level of hierarchy). An output port may be connected to multiple input ports, but an input port can only be connected to a single output port.
-3. _Events_ — Messages sent from one reactor to another, and timer and action events each have a tag (i.e., a timestamp), a value on a logical time line. These are tagged events that can trigger reactions. Each port, timer, and action can have at most one such event at any tag. An event may carry a value that will be passed as an argument to triggered reactions.
-4. _Reactions_ — A reaction is a procedure in a target language that is invoked in response to a trigger event, and only in response to a trigger event. A reaction can read input ports, even those that do not trigger it, and can produce outputs, but it must declare all inputs that it may read and output ports to which it may write. All inputs that it reads and outputs that it produces bear the same timestamp as its triggering event. I.e., the reaction itself is logically instantaneous, so any output events it produces are logically simultaneous with the triggering event (the two events bear the same timestamp).
-5. _Flow of Time_ — Successive invocations of any single reaction occur at strictly increasing tags. Any messages that are not read by a reaction triggered at the timestamp of the message are lost.
-6. _Mutual Exclusion_ — The execution of any two reactions of the same reactor are mutually exclusive (atomic with respect to one another). Moreover, any two reactions that are invoked at the same tag are invoked in the order specified by the reactor definition. This avoids race conditions between reactions accessing the reactor state variables.
+3. _Events_ — Every event has a tag (a form of timestamp), and every reactor reacts to events in tag order. When a reactor reacts to more than one event with the same tag, the reaction order is deterministic, so the results are predictable. Each port, timer, and action can have at most one event at any tag. An event may carry a value that will be passed as an argument to triggered reactions.
+4. _Reactions_ — A reaction is a procedure in a target language that is invoked in response to a trigger event, and only in response to a trigger event. A reaction can read input ports, even those that do not trigger it, and can produce outputs, but it must declare all inputs that it may read and output ports to which it may write. All inputs that it reads and outputs that it produces bear the same tag as its triggering event. I.e., the reaction itself is logically instantaneous, so any output events it produces are logically simultaneous with the triggering event (the two events bear the same timestamp).
+5. _Flow of Time_ — Successive invocations of any single reaction occur at strictly increasing tags. Any messages that are not read by a reaction triggered at the tag of the message are lost.
+6. _Mutual Exclusion_ — The execution of any two reactions _of the same reactor_ are mutually exclusive (atomic with respect to one another). Moreover, any two reactions that are invoked at the same tag are invoked in the order specified by the reactor definition. This avoids race conditions between reactions accessing the reactor state variables.
 7. _Determinism_ — A Lingua Franca program is deterministic unless the programmer explicit uses nondeterministic constructs. Given the same input data, a composition of reactors has exactly one correct behavior. This makes Lingua Franca programs _testable_.
-8. _Concurrency_ — Dependencies between reactions are explicitly declared in a Lingua Franca program, and reactions that are not dependent on one another can be executed in parallel on a multi-core machine. If the target provides a support for federated execution, then execution can also be distributed across networks.
+8. _Concurrency_ — Dependencies between reactions are explicitly declared in a Lingua Franca program, and reactions that are not dependent on one another can be executed in parallel on a multi-core machine. For targets supporting federated execution (currently C, Python, and TypeScript), execution can be distributed across networks.
+9. _Feedback_ - Messages can flow in feedback cycles. The compiler automatically identifies causality loops that may be introduced by the programmer. A causality loop makes it impossible for the compiler to determine an order of reaction invocation at a tag that preserves determinism.
 
 ## Getting Started
 To get started with Lingua Franca, [set up a development environment](./installation.md) and learn how to write [a first reactor](./writing-reactors/a-first-reactor.mdx). There are also a number of potentially useful [videos](./videos.mdx) available.

docs/videos.mdx

@@ -14,8 +14,11 @@ This page collects videos presented by the Lingua Franca team:
 
 ## Technical Talks
 
+* [Subtlteties with Decentralized Coordination in Lingua Franca](https://youtu.be/eUoqy6BLb0A), April 24, 2025.
 * [Decentralized Coordination in Federated Lingua Franca](https://youtu.be/eDBOwr5iD3s?si=rVzd4wXsUGgEHmvD), Nov. 20, 2024.
 * [Trading Off Consistency and Availability using Lingua Franca](https://youtu.be/3lHmiWOedHM?si=6E-SU58zx6n2dT6B), Nov. 10, 2024.
+* [Demo of LF Package Explorer in VS Code](https://youtu.be/9EgWKMowFiI), Oct. 25, 2024.
+* [Lingua Franca Edge AI](https://youtu.be/f2jHLAjER-c), Jul. 11, 2024.
 * [Deterministic Concurrency in Cyber-Physical Systems](https://youtu.be/OA_GknXKe4g?si=ulryQ7gpVivAfoX3), June 16, 2023.
 * [Deterministic Concurrency and the Lingua Franca Coordination Language](https://youtu.be/GT4NJ5XnEt4?si=wzrtX72PgAtPS_Yk), April 18, 2023.
 * [Verifying Parallel and Distributed Systems: The Observer Problem](https://youtu.be/20EKKsdWTQ8?si=aTSiPijMw9lDVajY), Feb. 9, 2023.

src/components/HomepageFeatures/index.tsx

@@ -20,7 +20,7 @@ const FeatureList: FeatureItem[] = [
     Svg: Determinism,
     description: (
       <Translate>
-        Lingua Franca offers a straightforward way to write multi-threaded applications that ensure determinism by default, eliminating concerns about thread management, synchronization, and race conditions.
+        Lingua Franca offers a straightforward way to write deterministic multi-threaded and distributed applications, eliminating concerns about thread management, synchronization, and race conditions.
       </Translate>
     ),
   },

src/pages/index.module.css

@@ -29,30 +29,7 @@
   color: var(--ifm-color-primary-light);
 }
 
-@keyframes jack-in-the-box {
-  0% {
-    opacity: 0;
-    transform: scale(0.1) rotate(30deg);
-    transform-origin: center bottom;
-  }
-
-  50% {
-    transform: rotate(-10deg);
-  }
-
-  70% {
-    transform: rotate(3deg);
-  }
-
-  100% {
-    opacity: 1;
-    transform: scale(1);
-  }
-}
-
 .heroLogo {
-  animation-duration: 2s;
-  animation-name: jack-in-the-box;
   float: left;
   margin-top: 100px;
   margin-right: 35px;

src/pages/index.tsx

@@ -32,7 +32,7 @@ function HeroBanner() {
               __html: translate({
                 id: "homepage.hero.title",
                 message:
-                  "Build <b>time-sensitive</b>, <b>concurrent</b>, and <b>distributed</b> systems — <b>effortlessly</b>",
+                  "Build predictable <b>concurrent</b>, <b>time-sensitive</b>, and <b>distributed</b> systems.",
                 description:
                   "Home page hero title, can contain simple html tags",
               }),
@@ -44,9 +44,10 @@ function HeroBanner() {
         <div className={styles.subHero}>
             <br/>
             <Translate>
-            Lingua Franca allows you to write blazing-fast, deterministic,
-            multi-threaded and distributed code without any knowledge about threads or synchronization.
-            Focus on your application, not elusive concurrency bugs.
+            Lingua Franca is a coordination language for efficient, deterministic,
+            multi-threaded, time-sensitive, embedded, and distributed programs. The result of decades
+            of research, it offers more repeatable behavior than other concurrent programming
+            frameworks, including threads, pub-sub, actors, and service-oriented architectures.
             </Translate>
         </div>
         <div className={styles.indexCtas}>
@@ -88,7 +89,7 @@ const Intro = (): JSX.Element => (
         <br/><br/>
         <Translate>
           Consider a game of "rock paper scissors" where two players need to reveal their choice simultaneously. In Lingua Franca, "at the same time" has a clear and precise meaning.
-          This makes the implementation simple and intuitive, and guarantees it to be fair. If the Player class were to observe the other's choice before revealing its own, Lingua Franca's causality analysis would find a causality loop and tell you that the program was invalid.
+          This makes the implementation simple and intuitive, and guarantees it to be fair. If the Player class were to observe the other's choice before revealing its own, Lingua Franca's causality analysis would find a causality loop and tell you that the program is invalid.
         </Translate>
         <br/><br/>
         <Heading as="h2">

versioned_docs/version-0.5.0/developer/downloading-and-building.mdx

@@ -41,7 +41,7 @@ For more details on our testing infrastructure, please refer to the [Regression
 If you only want to build without running any tests, you can use `./gradlew assemble` instead.
 Both the assemble and the build task will create a distribution package containing our command line tools in `build/distribution`.
 There is also an installed version of this package in `build/install/lf-cli/`.
-If you run `build/install/lf-cli/bin/lfc` this will run lfc as it was last build.
+If you run `build/install/lf-cli/bin/lfc` this will run lfc as it was last built.
 Thus, you can choose if you want to use `bin/lfc-dev`, which first builds `lfc` using the latest code and then runs it, or if you prefer to run `./gradlew build` and then separately invoke `build/install/lf-cli/bin/lfc`.
 
 ## IDE Integration