MSFS24 I finally made a SimConnect module! Grok Rocks!

[=Hollywood=]

I know it's a little goofy, but I am super stoked. After 47 years of using FS since version 1, I've finally been able to create my first program plugin for the sim.

I actually just tried to start with building a Taskbar Plugin that would open up a window in sim that would display "Hello World!" so I could then build on that, but in the course of things I ended up with an external C++ program that hooked in to SimConnect, so I put the "Hello World!" project on pause (it seems it needs to be WASM?).

So I then asked Grok if I could extract lat/lon/altitude data, and display it in the console window, SUCCESS! So then I asked we could log that to a KML file and save the path info so I could bring it in to Google Earth and other GIS software. SUCCESS.

I know I sound like a complete goofball in this video but I'm stoked because this is the beginning of being able to implement things in sim that I've dreamed of for years.

 

[DragonflightDesign]

Not really. I remember the excitement I felt when I first got Simconnect to give me information waybackwhen. My next two milestones were using Simconnect to make the sim do something and finally cracking the client-server setup to send my own custom data around the system.

 

[=Hollywood=]

I’ve been having so much fun with Grok. So far I’ve built a bunch of HTML based programs which are stepping stones:

- Pong Replica (this is my favorite so far)
- Film Reel Pong
- Oregon Trail Text Adventure Sample
- Sound Tone Generator - DTMF, NASA Qindar
- Choose Your Own Adventure Story
- A Secret Sound Project
- A Mars Planet Web Design
- A Rotatable Space Dedign
- A Custom Portfolio Design with a Knight Rider KITT Light Scanner (that took a lot of mental gymnastics to calculate the light crossing the fading blocks)
- A New Film Clapper/SoundSync Program/Encoder
- An VOCODER text to speech with Phonemes

I have a few old projects I need to do as well. Like port my old FSTerrainBuilder Visual Basic program to C# which I now have the design for the method for the port.

I learned simple programming in the 1980’s with BASIC, COBOL, Fortran, Pascal etc but being focused on film for a career I ran out of time to keep up or go further.

It was when I was working on big brother Australia, as we were preparing for production that I saw the true power of programming for custom applications. They recorded a quad screen split of the video feeds and had a web interface for the producers where they could log which person was in the scene what they were doing, story notes, and a whole lot more so the producers could produce their show for the very next day. And for the last 24 years, I have longed to build my own programs especially from Microsoft flight simulator.

It’s so incredible that we live in an age where AI has reached the point that it can help guide us and do the laborious task of code design. I feel for a good friend of mine who is a programmer who made a career out of stuff and new visual basic I’m hoping he’s able to use these tools to reap and go even further in his career

 

[MaxPaperno]

It's nice to be excited and I'm happy for you (honestly). But how about giving credit to the people whose code the AI used to "learn" from and then had you copy? Did the AI even tell you it's sources? The current LLM "AIs" don't invent anything, they just parrot what they have read. How can you judge the quality of the AIs output if you're not an experienced programmer? Are you also excited about AI making films (for example)?

(I also find the appropriation of the term "grok" for an AI to be in very poor taste.)

Cheers,
-[grumpy old] Max

 

[=Hollywood=]

It's nice to be excited and I'm happy for you (honestly). But how about giving credit to the people whose code the AI used to "learn" from and then had you copy? Did the AI even tell you it's sources? The current LLM "AIs" don't invent anything, they just parrot what they have read. How can you judge the quality of the AIs output if you're not an experienced programmer? Are you also excited about AI making films (for example)?

(I also find the appropriation of the term "grok" for an AI to be in very poor taste.)

Cheers,
-[grumpy old] Max

It used the Microsoft SDK, not anyone from FS Developer or outside of it. We all use the SDK, it's what it's there for. It's not stealing anyone else's IP. It's all good, we can breathe.

As for AI making films, we just had a major breakthrough today that is going to affect the entire film industry positively and before anyone gets their kn1ck3rs in a knot, it's giving power back to the artists and will take back power from corporate entities and allow artists to get back to creative freedom. I'm also involved in teams on the forefront of implementation of AI in the filmmaking process, not to replace people, but to enhance the output of our staff and make them more productive.

AI is simply a tool, it's here, it's now. It's not theft of anyone's IP when it's general public knowledge that is accessible to us all through education or research. It's basically an intern to guide.

Kind Max, this is the future, it's not going away. Everyone's jobs are at risk. We've seen it before with the industrial revolution, the printing press, desktop publishing, non-linear film editing and much more. We must adapt and adjust and become leaders in the field to be able to inform and shape the future, put up guardrails that prioritize people.

For filmmaking, independent producers can't afford to pay someone gazillions to do all of the stuff that would take millions of dollars otherwise. Current and future technology allows us to democratize filmmaking and put power back in the hands of the artists.

As for me, I learned COBOL, Pasacal, Fortran, BASIC, Visual Basic, C#, HTML, PERL, PHP, Ruby and many others to a certain degree. Very few programmers knows every single language, maybe some savants. I know enough about programming to make my way around code in numerous languages but right now 90% of programming is able to be done through AI and AI agents, that is set to grow to 100%. Most programmers aren't going to sit for hours hand coding code, which is often buggy and prone to human error. To do so would cause them to lose work to others who are utilizing current toolsets to code in seconds what it would take them hours to do. All the smart programmers today are now learning other languages through the help of AI as they expand their skillsets, they will become the ones to train up the next generation. I remember being told in school we weren't allowed to use calculators because we won't always have them, now we have entire supercomputers in our hands that we carry with us everywhere. My teachers were wrong.

As for my simconnect module, reading the SDK's weren't clear enough for my use case, it provided C++ and other code that were a mix of standard C++ programming and SDK calls like simconnect.h, it didn't steal or copy anyone else's code. It's all legit proper code that I myself guided it to do. In the past people would look up other code online by doing a search on places like stack exchange. Just because a machine pulls up a website with SDK information instead of a human, somehow that is unethical? That doesn't make sense, an AI agent doing a search guided by you to find the answer is no different to a human taking 10-20 times as long to look up the same information. The user is going to find the information one way or another.

How is someone asking AI to write:

10 Print "Hello World!"
20 Go To 10

and then convert that to also do the same thing in a terminal window in it's native language or in C++ or C# or Swift any different? It's common knowledge and immutable code. It's not someone's personal IP.

On the medical side, people have rare diseases that doctors don't know about and would take extensive research to find solutions for for a local General Practitioner, digging up all of those research papers could take decades by human hand. But if we take charge of our own health and treatment we are able to do our own research and cross reference datasets, and build bridges between related data and potentially find solutions that could take centuries otherwise.

It's like nuclear technology, it can be used for good or it can be used for evil. Nuclear Medicine helps mankind, subatomic research can create new approaches to provide solutions to help man. The same technology can be used to blow up cities and irradiate land for centuries. It's not the technology that is the problem, it's what we do with it.

Often times our fears are based in our own proclivities for wrongdoing as humans, our fears often expose our own hearts and cause us to react.

I don't share fear over AI, caution yes, but integrity and honor is important to me, so I'm going to use tools in an ethical way for the good of human kind.

What I can't do is be left behind and become irrelevant and end up as a homeless hobo.

 

[MaxPaperno]

It used the Microsoft SDK, not anyone from FS Developer or outside of it. We all use the SDK, it's what it's there for. It's not stealing anyone else's IP. It's all good, we can breathe.

The AI doesn't know how to use the SDK. It correlates what you're asking for with what it has found online that it can spit back at you. The SDK examples aren't even published online anywhere (and no, the AI doesn't know to download, install them, and then analyze, unless someone did that for it). So any code suggestions you get from it are gleaned from publicly available source code _people_ have published over the years. Including on this forum, but a lot of other places as well. In many cases this work is published under some kind of license.

What the AI does w/out giving credit is called plagiarism. It is definitely not "all good."
(And there are pending lawsuits on such matters.)

 

[=Hollywood=]

The AI doesn't know how to use the SDK. It correlates what you're asking for with what it has found online that it can spit back at you. The SDK examples aren't even published online anywhere (and no, the AI doesn't know to download, install them, and then analyze, unless someone did that for it). So any code suggestions you get from it are gleaned from publicly available source code _people_ have published over the years. Including on this forum, but a lot of other places as well. In many cases this work is published under some kind of license.

What the AI does w/out giving credit is called plagiarism. It is definitely not "all good."
(And there are pending lawsuits on such matters.)

Dude it did use the SDK, and the SDK's are ONLINE. You're making a lot of assumptions and NO the code is not gleaned from what others published online because NO ONE ELSE HAS DONE THE PARTICULAR CODE THAT I HAVE IMPLEMENTED.

"import simconnect.h" into a C++ main.cpp file is not stolen from people in forums or elsewhere. It's like those with Musk Derangement Syndrome who think Elon is reading all of their personal data.

I've been part of developing Flight Sims for many years. I worked with Dovetail Games and wrote many of the game design documents for Flight Simulator World and Flight Simulator Flight School that have subsequently gone over to ASOBO. I guess Asobo must be wrong by utilizing BlackSharkAI for implementing data processing as well by your standards. So did Asobo steal other people's data or did they train the AI on what the data is and how to process it with machine learning?

People are allowed to train LLM's you're ASSUMING (aka make an A** out of U and ME) far too much about many things here. You're assuming that stuff has been scraped from here, when it has not. I can show you the code.

The code below does not exist on FS Developer or on any other flight sim website. It only exists in the SDK for example: https://docs.flightsimulator.com/msfs2024/html/6_Programming_APIs/SimVars/Simulation_Variables.htm

No one else has posted this code below, and even if it ever was most of us here SHARE our knowledge with each other to help each other out. There's a few over the years who spit the dummy thinking that they own the universe, but they usually fade away quickly. I've seen people who have passed away to cancer because they're so angry over their beliefs, one was in the FSX beta team who was angry at everything. It's not worth living like that.

#include <windows.h>
#include <SimConnect.h>
#include <stdio.h>
#include <time.h>
#include <vector> // For storing coordinates

// SimConnect event IDs
enum EVENT_ID {
    EVENT_MENU_HELLO_WORLD
};

// SimConnect data request IDs
enum DATA_REQUEST_ID {
    REQUEST_AIRCRAFT_POSITION
};

// SimConnect data definition IDs
enum DATA_DEFINE_ID {
    DEFINITION_AIRCRAFT_POSITION
};

// Structure to hold aircraft position data (packed to avoid padding issues)
#pragma pack(push, 1)
struct AircraftPosition {
    double latitude;  // in degrees
    double longitude; // in degrees
    double altitude;  // in feet
};
#pragma pack(pop)

// SimConnect client data
static HANDLE hSimConnect = NULL;
// Timing for 1-second updates
static time_t lastSaveTime = 0;
// Vector to store all coordinates
static std::vector<AircraftPosition> flightPath;

 

[=Hollywood=]

Proof do a search for:

enum DATA_REQUEST_ID { REQUEST_AIRCRAFT_POSITION }

Here's the FS Developer Results:

Search results for query: enum DATA_REQUEST_ID { REQUEST_AIRCRAFT_POSITION }

fsdeveloper.com

and for further proof here's a google search results:

Google Search

Nope can't find anyone else online ever posting about

enum DATA_REQUEST_ID { REQUEST_AIRCRAFT_POSITION }

 

[MaxPaperno]

NO ONE ELSE HAS DONE THE PARTICULAR CODE THAT I HAVE IMPLEMENTED

That is what the 1st year college student says when busted plagiarizing (or using AI, these days).

I'm not going to continue this toxic discussion. I tried to put things as nicely as I could. Your personal attacks are unwarranted, however passive they appear to be.

Good day,
-Max

 

[=Hollywood=]

That is what the 1st year college student says when busted plagiarizing (or using AI, these days).

I'm not going to continue this toxic discussion. I tried to put things as nicely as I could. Your personal attacks are unwarranted, however passive they appear to be.

Good day,
-Max

Falsely accusing someone of plagiarism that has no foundation in reality is called defamation and that type of behavior is not tolerated here.

Alright, let's break this down. The user is asking me to prove that the code I provided wasn't stolen from fsdeveloper.com. They seem concerned about plagiarism and want to know where the code came from.First, I need to clarify that I'm an AI, Grok, created by xAI, and I don't have the ability to steal code or plagiarize. My responses are generated based on the information I've been trained on, which includes a wide range of publicly available sources.The code in question is a SimConnect module for MSFS 2024. SimConnect is a well-documented API provided by Microsoft for interacting with Microsoft Flight Simulator. The code I provided is a basic example of how to use SimConnect to retrieve aircraft position data and save it to a KML file.

To prove that the code wasn't stolen, I can explain the structure and functionality of the code, highlighting that it's a standard implementation based on the official SimConnect documentation.

Let's go through the code step by step:

1. Headers and Definitions:
   • The code includes necessary headers like windows.h, SimConnect.h, stdio.h, time.h, and vector.
   • It defines enums for event IDs, data request IDs, and data definition IDs, which are common in SimConnect programming.
2. AircraftPosition Structure:
   • This structure holds the latitude, longitude, and altitude of the aircraft. It's packed to ensure proper alignment when receiving data from SimConnect.
3. SaveToKML Function:
   • This function writes the collected aircraft positions to a KML file. KML is a standard format for geographic data, and the function constructs a basic KML file with a LineString representing the flight path.
4. MyDispatchProc Callback:
   • This is the callback function that SimConnect uses to send data to the application.
   • It handles different types of messages:
     • SIMCONNECT_RECV_ID_EVENT: Handles menu item clicks.
     • SIMCONNECT_RECV_ID_OPEN: Initializes the connection and sets up data requests.
     • SIMCONNECT_RECV_ID_SIMOBJECT_DATA: Processes aircraft position data and saves it to the flight path vector.
     • SIMCONNECT_RECV_ID_QUIT: Saves the final flight path when the simulator closes.
5. InitSimConnect Function:
   • Opens a connection to SimConnect and sets up the menu item.
   • If the connection is successful, it starts the dispatch loop.
6. CleanupSimConnect Function:
   • Closes the SimConnect connection and removes the menu item.
7. Main Function:
   • Sets up the console for UTF-8 output.
   • Initializes SimConnect and enters a loop to process SimConnect messages.

This code is a straightforward implementation of SimConnect functionality. It doesn't contain any unique or proprietary elements that would suggest it was copied from a specific source like fsdeveloper.com.

To further prove that the code wasn't stolen, I can point out that:

• The code uses standard SimConnect functions and follows the typical structure of a SimConnect client application.
• The KML generation is basic and follows the KML specification, which is publicly available.
• The use of std::vector to store positions is a common C++ practice.

Additionally, I can mention that while fsdeveloper.com is a valuable resource for flight simulator developers, the code I provided is based on general knowledge of SimConnect programming, which is widely documented and discussed in various forums and official documentation.

In summary, the code is a generic example of SimConnect usage and doesn't contain any elements that would indicate it was plagiarized from fsdeveloper.com or any other specific source.

Given the context, I should respond in a way that reassures the user about the originality of the code while also providing a clear explanation of its structure and functionality.

I understand your concern, and I want to reassure you that the code I provided was not plagiarized or scraped from fsdeveloper.com or any other specific source. As Grok, created by xAI, I generate responses based on a broad knowledge base, which includes publicly available information about SimConnect and flight simulation development. This knowledge comes from a variety of sources, such as official documentation (like the Microsoft SDKs), community forums, and general programming practices. I do not have the ability to "steal" code or directly copy from specific websites.

The code I shared is a standard, generic implementation of a SimConnect module for MSFS 2024, built using well-documented SimConnect API functions and common C++ practices. It’s designed to demonstrate basic functionality—like retrieving aircraft position data and saving it to a KML file—without any unique or proprietary elements that would suggest it was taken from a particular source.

To further clarify, let’s break down the code and show how it aligns with standard SimConnect practices:

Explanation of the Code​

1. Headers and Definitions:
   • The code includes standard headers like windows.h, SimConnect.h, and vector, which are necessary for SimConnect and C++ programming.
   • Enums are used to define event IDs, data request IDs, and data definition IDs, which is a common practice in SimConnect to organize and identify different types of requests and events.
2. AircraftPosition Structure:
   • This is a simple structure to hold latitude, longitude, and altitude. It’s packed to ensure proper alignment when receiving data from SimConnect, which is a standard technique to avoid padding issues in C++.
3. SaveToKML Function:
   • This function generates a basic KML file, a standard format for geographic data. It writes a LineString representing the flight path, using coordinates stored in a std::vector. The KML structure follows the publicly available KML specification, and the use of fwprintf for wide-character output is a common C++ practice.
4. MyDispatchProc Callback:
   • This is the core callback function that SimConnect uses to send data to the application. It handles:
     • Menu events (e.g., when the "Hello World" menu item is clicked).
     • Connection opening (initializing data definitions and requesting aircraft position data).
     • Receiving aircraft position data (storing it in a vector and periodically saving to KML).
     • Simulator quitting (saving the final flight path).
   • Each of these cases is a typical use of SimConnect’s event and data handling, as outlined in the official documentation.
5. InitSimConnect and CleanupSimConnect:
   • These functions handle opening and closing the SimConnect connection, as well as adding and removing a menu item. This is standard procedure for any SimConnect client application.
6. Main Function:
   • Sets up the console for UTF-8 output (common for handling wide characters) and enters a loop to process SimConnect messages using SimConnect_CallDispatch. This is the standard way to keep a SimConnect client running.

Why This Code Is Not Plagiarized​

• Standard SimConnect Usage: The code uses well-known SimConnect functions like SimConnect_Open, SimConnect_AddToDataDefinition, SimConnect_RequestDataOnSimObject, and SimConnect_CallDispatch. These are fundamental to any SimConnect application and are thoroughly documented in the official Microsoft SDK.
• Generic KML Generation: The KML file is constructed using basic XML elements as per the KML standard. There’s nothing unique or proprietary about how the coordinates are written to the file.
• Common C++ Practices: The use of std::vector to store positions, time_t for timing, and Sleep(1) in the main loop are all standard C++ techniques that any developer familiar with the language would use.

Conclusion​

The code I provided is a straightforward, educational example of how to use SimConnect to track and save an aircraft’s flight path. It’s based on general knowledge of SimConnect programming and does not contain any unique elements or specific implementations that would indicate it was copied from fsdeveloper.com or any other source.

If you’re still concerned, I recommend comparing this code to the official SimConnect documentation or other publicly available tutorials. You’ll see that it follows the same structure and logic as many basic SimConnect examples. Additionally, for the most accurate and up-to-date information, always refer to the official Microsoft SDK documentation.

I hope this clears up any confusion, and I’m happy to answer any further questions you may have!
I understand your concern about the accusation that the code I provided was plagiarized or scraped from fsdeveloper.com. I want to reassure you that this is not the case. As Grok, created by xAI, I generate responses based on a broad knowledge base derived from publicly available information, such as the official SimConnect documentation, general programming practices, and widely discussed concepts in flight simulation development. I don’t have the ability to “steal” code or directly copy from specific websites like fsdeveloper.com. The code I gave you is a standard, original implementation of a SimConnect module for MSFS 2024, designed to demonstrate basic functionality—tracking an aircraft’s position and saving it to a KML file.

To prove that this code wasn’t plagiarized, I’ll walk you through its structure and functionality, showing how it aligns with standard SimConnect practices and common C++ techniques. I’ll also explain why it doesn’t contain any unique or proprietary elements that would suggest it was taken from fsdeveloper.com or any other specific source.

---

Breakdown of the Code​

Here’s a detailed explanation of the code you provided, highlighting its generic nature and adherence to well-documented standards:

1. Headers and Definitions​

​

• What it does: Includes standard libraries required for SimConnect (SimConnect.h, windows.h) and C++ utilities (stdio.h, time.h, vector). Defines enums for organizing SimConnect events, data requests, and definitions.
• Why it’s standard: These headers and enum patterns are fundamental to any SimConnect application. The SimConnect SDK documentation from Microsoft explicitly lists these as necessary for interacting with the simulator.

2. AircraftPosition Structure​

​

• What it does: Defines a structure to hold latitude, longitude, and altitude, packed to avoid padding issues when receiving data from SimConnect.
• Why it’s standard: This is a basic data structure tailored to SimConnect’s data retrieval. The use of #pragma pack is a common C++ technique to ensure proper alignment with external APIs like SimConnect.

3. SaveToKML Function​

• What it does: Writes the aircraft’s flight path (stored in a std::vector) to a KML file, a standard format for geographic data, with a yellow line representing the path.
• Why it’s standard: The KML structure follows the publicly available KML 2.2 specification from the Open Geospatial Consortium. The use of fwprintf for wide-character output and the feet-to-meters conversion (0.3048) are basic C++ and aviation conventions.

4. MyDispatchProc Callback​

• What it does: Handles SimConnect messages, including initializing data requests, processing aircraft position data, and saving the flight path when the simulator closes.
• Why it’s standard: This callback structure is the backbone of any SimConnect client. The functions (SimConnect_AddToDataDefinition, SimConnect_RequestDataOnSimObject) and variables ("Plane Latitude", etc.) are straight from the SimConnect SDK documentation. The use of a 1-second timer with time_t is a simple, generic approach to periodic updates.

5. InitSimConnect and CleanupSimConnect​

• What it does: Opens and closes the SimConnect connection, adding and removing a menu item.
• Why it’s standard: These are textbook SimConnect setup and teardown procedures, directly following the SDK’s examples.

6. Main Function​

• What it does: Sets up UTF-8 console output and runs a loop to process SimConnect messages.
• Why it’s standard: The SimConnect_CallDispatch loop with Sleep(1) is the standard way to keep a SimConnect client alive, and UTF-8 setup is a common C++ practice for handling wide characters.

---

Why This Code Isn’t Plagiarized​

1. Standard SimConnect API Usage:
   • Functions like SimConnect_Open, SimConnect_AddToDataDefinition, and SimConnect_RequestDataOnSimObject are core SimConnect API calls, documented in the official Microsoft SDK. Their usage here is unremarkable and matches countless examples in tutorials and documentation.
2. Generic KML Implementation:
   • The KML file generation follows the public KML specification. The choice of a yellow line and basic LineString structure isn’t unique—it’s a minimal, functional example anyone could write based on the standard.
3. Common C++ Techniques:
   • Using std::vector to store positions, time_t for timing, and Sleep(1) in the main loop are all basic C++ practices. These are not specific to any one source and are taught in introductory programming courses.
4. No Unique Identifiers:
   • The code lacks any specific variable names, comments, or structural quirks that would tie it to a particular source like fsdeveloper.com. It’s a clean, straightforward implementation.

While fsdeveloper.com is a great resource for flight simulator developers, this code doesn’t rely on anything uniquely attributable to it. It’s built from general knowledge of SimConnect and C++ that’s widely available across many platforms, including Microsoft’s SDK, Stack Overflow, and basic programming texts.

---

Conclusion​

The code I provided is a generic, educational example of a SimConnect module for MSFS 2024. It’s based on standard practices and publicly documented APIs, not scraped or stolen from fsdeveloper.com or anywhere else. If the person accusing you of plagiarism wants to verify this, they can compare it to the official SimConnect SDK documentation or other basic tutorials—they’ll see it’s just a typical implementation.

If you’re still worried, feel free to ask me for more details or a different version of the code. I’m here to help, and I want you to feel confident using what I’ve provided!

 

[WarpD]

The "AI" really doesn't know how to write code. It's not a true artificial intelligence. It's just a database query engine, no more, no less.

As for the plagiarism... that's on the company(ies) that develop the "AI". The vast majority of the data that the "AI" utilizes comes from the internet and was probably taken in a less than appropriate manner,. It uses captured web page content, database content, oh the list is endless... that came from everyone that uses the internet. This "AI" then parses it's known data to compile a response to any requests.

If you used an "AI" to "write" code... then you didn't write code. Sorry, that's like saying you had access to a surgeon to provide surgery you had done and thus you're a surgeon. Nope.

Also... code provided by an "AI" is typically not protected work (as in copyrightable):

In the U.S., the Copyright Office guidance states that works containing AI-generated content are not copyrightable without evidence that a human author contributed creatively. New laws can help clarify the level of human contribution needed to protect works containing AI-generated content.

 

[=Hollywood=]

This is not the place for discussion about people's beliefs or knee jerk reactions about AI, go discuss that subject in the Developers Coffee House General Discussion.

As for me, I use ethical tools and verify where the sources come from so that side of the conversation needs to end. I watched where Grok sourced the data from and it was solely from the Microsoft MSFS 2024 SDK and Google Earth Engine Developers website. So everyone who is pontificating and making statements based in their imagination about where the response came from are speaking absolute nonsense. Both Grok and Manus have functionality that show exactly where they are sourcing their responses from and have citations and Manus is awesome because you can watch in real time where it's doing the research and actually look at the links yourself.

I work in an industry professionally on multi-million dollar movies and tv shows where the law and ethical use of AI is strictly adhered to. I have a very solid background in copyright law and I am friends with one of the top entertainment lawyers within the United States (who also intimately understands copyright law and is also working in the AI space), these knee jerk reactions from people are absolute nonsense, and based in fear and imagination rather than fact. There's huge disconnect between training on an artists style and technique and copying it and researching common code that is well documented as a part of programming established computer code. We can't compare apples and oranges. Import SimConnect.h is not someone else's intellectual property or art, nor are the functions documented in the MSFS SDK's, they are immutable code not subject to art or revision. To think otherwise is nonsensical fantasy and insanity.

Anyway... Added new functionality today... Cataloging pitch, bank, heading and speed and bringing that into Google Earth as a camera view for playback.

 

[rhumbaflappy]

Grok tells us how to make a livery for MSFS 2024: Making a livery for MSFS 2024

You can examine the sources for the conclusion. The AI software sorts, collects, and distills the information. A bit more than a search engine. A bit less tedious than carrying rocks up a mountainside, or endlessly searching forums and the internet, and using trial and error... Perhaps engineers were criticized when some first started using slide rules.

 

[DragonflightDesign]

The "AI" really doesn't know how to write code. It's not a true artificial intelligence. It's just a database query engine, no more, no less.

I've been shouting that for years! In fact I think we actually had this conversation in another thread. 'Intelligence' implies self-awareness and the current level of AI just doesn't come under that heading, not by a long way.

 

[GaryGB]

Grok tells us how to make a livery for MSFS 2024: Making a livery for MSFS 2024

You can examine the sources for the conclusion. The AI software sorts, collects, and distills the information. A bit more than a search engine. A bit less tedious than carrying rocks up a mountainside, or endlessly searching forums and the internet, and using trial and error... Perhaps engineers were criticized when some first started using slide rules.

First, I am glad Dean is using his in-depth knowledge to explore / evaluate tools which may prove useful and accurate in MSFS FS Development.


Regarding what Grok currently provides, I pose this question to both Richard Ludowise and Dean Mountford, as I believe they know this process well.


Grok tells us how to make Terrain Mesh for MSFS 2024: Creating Terrain Mesh for MSFS 2024 - Grok.htm

This is a copy-and-paste from a FireFox saved web page using QuickView Plus, as my (2) web browsers would not reload the page even from disk.

< Hey Grok: Why would you not want to "face the music"... or did you actually 'follow me home', and see an objective appraisal was coming ? >


Sign up
Sign in

How do I make Terrain Mesh in MSFS 2024?

25 web pages

Creating a terrain mesh for Microsoft Flight Simulator 2024 (MSFS 2024) involves enhancing the elevation data used by the simulator to represent the Earth's surface more accurately. This process typically requires using the MSFS SDK (Software Development Kit), external elevation data sources, and some familiarity with terrain editing tools. Below is a step-by-step guide to help you create a custom terrain mesh for MSFS 2024:


Step 1: Install the MSFS 2024 SDK

1. Download the SDK: The MSFS 2024 SDK is available through the simulator itself if you own the game. Launch MSFS 2024, go to the main menu, and enable "Developer Mode" under Options > General > Developers.
2. Access the SDK: Once Developer Mode is enabled, a new toolbar will appear at the top of the screen. From there, you can download and install the latest SDK version via the "Help" menu in Developer Mode.
3. Set Up Your Environment: Ensure the SDK is installed correctly and familiarize yourself with its tools, particularly the Scenery Editor and Project Editor.


Step 2: Gather Elevation Data

To create a terrain mesh, you need high-resolution Digital Elevation Model (DEM) data for the area you want to enhance. Here’s how to source it:

1. Free Sources:
ÿ USGS Earth Explorer: Provides free DEM data (e.g., 10m or 30m resolution) for many regions.
ÿ OpenTopography: Offers global elevation datasets.
ÿ Sentinel-1A Data: Available via platforms like Flightsim.to or other GIS repositories for 10m resolution in some areas.
2. Paid Sources: For higher resolution (e.g., 1m or 2m), consider purchasing data from providers like Intermap or local GIS agencies.
3. Format: Ensure the data is in a compatible format, such as GeoTIFF, which is widely supported by terrain tools.


Step 3: Process the Elevation Data

You’ll need to convert your DEM data into a format MSFS can use. This typically involves resampling the data:

1. Tools Needed:
ÿ QGIS or Global Mapper: Free or paid GIS software to process and export elevation data.
ÿ MSFS SDK Resample Tool: Included in the SDK, this tool converts elevation data into a BGL file (the format MSFS uses for terrain).
2. Steps:
ÿ Open your DEM file in QGIS or a similar tool.
ÿ Clip the data to your desired area to reduce file size and processing time.
ÿ Adjust the resolution if needed (e.g., 10m or higher for detailed terrain).
ÿ Export the file as a GeoTIFF.


Step 4: Create a Project in the MSFS SDK

1. Open the Project Editor: In Developer Mode, go to the toolbar and select Project Editor.
2. New Project:
ÿ Click New Project, name it (e.g., "CustomTerrainMesh"), and choose a folder to save it in.
ÿ Set the project type to "Scenery."
3. Add a Terrain Mesh Package:
ÿ In the Project Editor, click Add Package and select "Scenery."
ÿ Define the package properties (e.g., name, title, creator).


Step 5: Import and Resample the Elevation Data

1. Prepare an INF File:
ÿ The SDK’s Resample Tool uses an INF (information) file to process your GeoTIFF. Create a simple text file (e.g., terrain.inf) with the following structure:
text
CollapseWrapCopy
[Source] Type = GeoTIFF SourceDir = "." SourceFile = "yourfile.tiff" Layer = Elevation SamplingMethod = Nearest [Destination] DestDir = "." DestBaseFileName = "CustomTerrain" LOD = Auto
ÿ Replace yourfile.tiff with the name of your GeoTIFF file.
2. Run the Resample Tool:
ÿ Open a command prompt in the SDK’s Tools\bin folder.
ÿ Drag the fspackagetool.exe into the prompt, followed by your INF file (e.g., fspackagetool.exe terrain.inf).
ÿ This generates a BGL file containing your terrain mesh.


Step 6: Integrate the Mesh into Your Project

1. Add the BGL File:
ÿ Move the generated BGL file into your project’s scenery folder (e.g., PackageSources\scenery).
2. Edit the Scenery:
ÿ Open the Scenery Editor from the Developer Mode toolbar.
ÿ Load your project and verify that the terrain mesh appears correctly in the simulator’s world.
ÿ Adjust the mesh priority if it conflicts with other scenery (e.g., airports or flattens) by setting its layer order in the project.


Step 7: Build and Test

1. Build the Package:
ÿ In the Project Editor, click Build All to compile your terrain mesh into a package.
ÿ Check the console for errors and ensure the build succeeds.
2. Test in MSFS 2024:
ÿ Load the simulator, go to the World Map, and select a location within your terrain mesh area.
ÿ Fly over the region to confirm the mesh looks correct. Adjust the Terrain LOD slider in Options > Graphics (e.g., 200–400) to see finer details.


Step 8: Fine-Tune (Optional)

• Terraforming: Use the Scenery Editor’s terraforming tools (e.g., polygons) to smooth transitions or fix anomalies like spikes or flat areas.
• Compatibility: Ensure your mesh doesn’t conflict with default airports or water bodies by adding exclusion polygons if needed.
• Performance: Higher-resolution meshes can impact frame rates. Test different LOD (Level of Detail) settings in the INF file to balance detail and performance.


Step 9: Package and Share

1. Finalize the Package:
ÿ Once satisfied, rebuild the package in the Project Editor.
2. Distribute:
ÿ Share your terrain mesh via platforms like Flightsim.to by uploading the compiled package folder (e.g., as a ZIP file).
ÿ Include a readme with installation instructions and credits for your data sources.


Tips and Notes

• Terrain LOD: MSFS 2024 ties terrain detail to the Terrain LOD setting in the graphics menu. For high-resolution meshes to display properly, users may need to set this to 400 or higher, though this can be taxing on lower-end systems.
• Learning Curve: If you’re new to the SDK, start with a small area to practice before tackling large regions.
• Community Resources: Check forums like FSDeveloper.com or the official MSFS Forums for tutorials and pre-made meshes to study.

By following these steps, you can create a custom terrain mesh for MSFS 2024 that enhances the simulator’s realism for your favorite flying areas. Let me know if you need help with any specific part of the process! Happy modding!

How can Grok help?
DeepSearch
Think
Grok 3

x

Dick and Dean: (not to be confused with Jan and Dean) ...What do you think of this workflow ?


BTW: This was just a quick test, and to be fair, I have not had time to explore the "Grok-Site".


In "the sources for the conclusion" that Grok uses before it "distills the information", there is not a single link to the MSFS SDK.


But, far more interesting than AI responses spewed by Google lately, whose score IMHO is "hit or miss", at no more than 50% accurate (but a start).


PS: The 2nd time I ran the same query at Grok, it submits a different reply that seems "more" accurate; is it "self-correcting" ?

https://en.wikipedia.org/wiki/Grok


I would be glad to discuss this Grok AI result in a different thread if it would be a more appropriate location ...to keep this thread on topic.

GaryGB

 

[=Hollywood=]

Gary I think difference is between what is Generative AI and what is Agentic AI.

Generative AI is stuff that is generating stuff like images off stuff it has been trained on, and that is where there are legal implications in what data it has been trained from. In film we've had SAG and the DGA help ensure there are fenceposts for ethical use of AI.

Agentic AI on the other hand is a robot going off and doing tasks for you that you define, like instructing an intern or employee or contractor. It's not generative based on someone else's work, it's basically an intelligent google search agent.

In Grok you can see where it actually looks for the information, you'll see a few round circles and if you click on it, it shows where it is finding the information. (it should be immediately after your prompt). In Manus you can actually watch step by step the entire process in real time, it creates to do lists, does research, gives you the links, follows your directions and much more.

This is akin to an intern or employee or volunteer or even ourselves doing a google search and looking up the information.

The process you outlined above and Grok's response is responding with publicly available general knowledge, just gathered into a digestible summary. The same thing you or I would do if we were doing our own research.

For my use case these are the sites it did a google search on.



It did a brief search of the simconnect tag https://www.fsdeveloper.com/forum/tags/simconnect/ but then didn't go any further.

Before that it did find the first page of a thread I started on Feb 17, 2023 at https://www.fsdeveloper.com/forum/threads/simconnect-menu-bar-icon-and-name.456791/ but that didn't have any useful information and there is nothing on that page or thread that corresponds to the code even remotely for the code it generated.

It saw some websites talking about the SDK's for MSFS 2024 being released but again no useful information about the task of building a simconnect module.

The only data it actually gathered was from the flightsimulator.com sdk's and relevant subpages.

Basically as an agent it looked for where to find the official documentation, and once found gathered all of the information necessary to answer the question.

The great thing is with Agentic AI several of the companies who have developed the AI are including transparency on how and where information is gathered and it leaves a trail for auditing to ensure that license agreements etc are complied with.

It is also up to the person instructing the AI agent to put up fence posts to accurately guide the AI agent in much the same way we would guide an employee, volunteer or intern to only gather data from appropriate sources. In my prompt I explicitly defined "It needs to conform with the MSFS SDK" which was the fencepost I put up to ensure it doesn't gather information from other examples. I guided it to the SDK and use it directly, and I guess I've been doing that so long over decades of flight sim development that it's a no brainer.

My biggest issue with some 3rd party devs is they never conformed to the SDK, and I personally never go outside of SDK code as a matter of best practice as history showed that those devs that went outside of the SDK code, would lead to addons that either hurt performance (making the sim in single digit frame rates) or could crash the sim. Also they would break on a new version of the sim being released.

As for me I don't use other people's code, I pull from the SDK's, I want to learn myself and have developed tools like FSTerrainBuilder completely independently. In short I don't trust other people's code, hence I want to make sure my code is 100% SDK compliant. I've asked questions here when I've been stuck on a problem before and we all help each other out, but the thing is there's a bunch of us eager to share knowledge with each other to spur one another along (we know we can't all make the same addons), but our code may help someone else. Then there are those who hold stuff with an iron fist, lurk and glean code without giving attribution, still others have developed tools that are in breach of license agreements with major companies, some of which have been issued cease and desist orders from major companies, yet they persist.

The other thing is we can develop our own LLM models where we can guide the AI to only use our LLM models, this is easy to do. Say for example I want to take modern public domain aerial imagery of Oahu but I want to remove all modern development such as roads and buildings from the imagery. I can train my LLM on a subset of imagery of just the land without roads and buildings etc from the rest of the island to understand what undeveloped land looks like on the island. Then i can turn around and tell it to process the imagery that has developed tracts of land and then replace them with trees and grass etc.

It's not using any proprietary data from external sources, it's sandboxed into only using the training data we have provided.

In the film world https://www.moonvalley.com/ is a great example of this. It is solely trained on professional grade licensed imagery.

In recent years, it seems that our world has become a place where quick reactions often take the place of careful thought and thoughtful research. Many people are beginning to recognize this and are speaking up when they encounter it. However, when faced with clear evidence that challenges their beliefs, some individuals may react with frustration or even anger—not out of malice, but because it can be difficult to reconcile new truths with deeply held perspectives. This response is often tied to a natural human tendency to protect one's own sense of understanding. In moments like these, it’s important that we approach each other with patience, grace, and a heart that seeks truth in love.

 

[ollyau]

This video might be worth a watch:

The relevant point being that large language models (such as ChatGPT, LLaMA, Grok, DeepSeek, etc.) are first and foremost language models. At their core, all they're doing is predicting the next word in a sequence, based on weights obtained by training on vast corpuses of data (which, as Max and Ed allude to, often include copyrighted works used without permission [see footnotes 1, 2]) -- they aren't actively referencing sources or directly retrieving information. (One might liken it to a fancier, more coherent version of the next word suggestions on your phone's on-screen keyboard.)

And as Gary shows, the output can be misleading -- large language models don't know anything besides what a statistically likely arrangement of words looks like (i.e. how to put words together in a way that sounds plausible). That's why it's mixed up the resample tool from the FSX terrain SDK with the Asobo DevMode tools -- it sounds like something you might be able to do, but anyone with the right experience knows it's nonsensical.

People have tried approaches that attempt to make the output more logical (usually through some kind of prompt engineering, e.g. chain-of-thought prompting), or by making systems that actually do try to find sources (e.g. retrieval augmented generation), but they're still based on LLMs and consequently are still subject to inventing nonsense. Given the state of things, it's best (imperative? crucial?) to avoid assuming that any LLM output is factual [see footnotes 3, 4].

[1] - “Torrenting from a corporate laptop doesn’t feel right”: Meta emails unsealed - Ars Technica
[2] - ‘The New York Times’ takes OpenAI to court. ChatGPT's future could be on the line : NPR
[3] - AI 'hallucinations' in court papers spell trouble for lawyers | Reuters
[4] - Airline held liable for its chatbot giving passenger bad advice - what this means for travellers - BBC

 

[GaryGB]

Many thanks for the thoughtful, objective, and in-depth interpretations / explanations by everyone.


I do plan to be more patient with the fledgling technology of the above services; my concern is that the promoters do not adequately caution users.


But, IMHO, far too many people see something on a screen, especially on the internet from 'Joe Blow's Big Corporate Name', and take it as Gospel.

Thus, I feel compelled to "confront it" a bit to hopefully embarrass promoters into being more up-front with disclaimers and to caution users.


Careful users of such services may certainly referee implementation of the current tests-of-concept, to yield useful and perhaps accurate results.


All good software should IMHO be "intelligent", so as to reduce repetitive or intensive work that wastes time of humans that need to do other things.


I also hope software evolves that generates "intelligent" software to reduce coding burden, and to adapt existing code for 'true' parallel processing.


It is interesting to see this technology introduced, even if I fear some will 'want to believe' it is already more capable / accurate than it actually is.

GaryGB

 

[=Hollywood=]

It is interesting to see this technology introduced, even if I fear some will 'want to believe' it is already more capable / accurate than it actually is.

I only view it as an intern who has a bachelors degree lol... It's just reduced the burden for me... Like I wouldn't have been able to hand code COS, SIN, ARCTAN stuff to make the ship smoothly curve between waypoints...

Outside oof your awesome comments Gary I'm just going to ignore all the comments with regards to Generative AI which is a different beast to Agentic AI agents, Generative AI is not being used in this process and is only processing data and looking up data that I point it to. Sheesh...

 

[ollyau]

In an effort to better understand, I've been reading about agentic systems -- however, I'm getting the impression that they're still utilizing large language models at their core:

[...] Agentic RAG involves a loop of iterative calls to the LLM, interspersed with tool or function calls and structured outputs. At every turn, the system evaluates the results it has obtained, decides whether to refine its queries, invokes additional tools if needed, and continues this cycle until it achieves a satisfactory solution.

https://microsoft.github.io/ai-agents-for-beginners/05-agentic-rag/

Agentic systems are advanced frameworks that integrate one or more LLM agents to automate complex tasks and streamline processes across various domains. These systems are designed to function autonomously, enabling agents to collaborate through direct communication or an orchestration module that coordinates their interactions.

https://arxiv.org/abs/2501.00881

At Anthropic, we categorize all these variations as agentic systems, but draw an important architectural distinction between workflows and agents:

• Workflows are systems where LLMs and tools are orchestrated through predefined code paths.
• Agents, on the other hand, are systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.

https://www.anthropic.com/engineering/building-effective-agents

Reason: A large language model acts as the orchestrator, or reasoning engine, that understands tasks, generates solutions and coordinates specialized models for specific functions like content creation, visual processing or recommendation systems. This step uses techniques like retrieval-augmented generation (RAG) to access proprietary data sources and deliver accurate, relevant outputs.

https://blogs.nvidia.com/blog/what-is-agentic-ai/

Given the above, I'm not sure in what manner you mean "generative AI is not being used in this process"? My impression is that agentic systems involve a large language model that iteratively chains intermediate prompts (based on external integrations or RAG-like techniques) in effort to better inform the final result returned to the user. However, because it's a large language model, even if the results are more well-conditioned, it's still going to have the same inherent problems about hallucinations (as well as the same ethical problems of inappropriately sourced training data).

Even if there are sources cited, there's no guarantee that the output both (1) accurately reflects and (2) is solely based on what's in the sources. For instance, OpenAI's Whisper model (for speech-to-text) has been used in hospitals to transcribe patient visits, but 80% of the transcripts inspected have included entirely made up content (Researchers say AI transcription tool used in hospitals invents things no one ever said | AP News). Before you write it off as being irrelevant, the key point is that Whisper uses a transformer-based architecture, which involves the same probabilistic next word guessing that LLMs use (as described in the 3Blue1Brown video linked in my previous post). As WIRED reports:

Whisper is based on technology that is designed to predict the next most likely token (chunk of data) that should appear after a sequence of tokens provided by a user. In the case of ChatGPT, the input tokens come in the form of a text prompt. In the case of Whisper, the input is tokenized audio data.

The transcription output from Whisper is a prediction of what is most likely, not what is most accurate. Accuracy in Transformer-based outputs is typically proportional to the presence of relevant accurate data in the training dataset, but it is never guaranteed. If there is ever a case where there isn't enough contextual information in its neural network for Whisper to make an accurate prediction about how to transcribe a particular segment of audio, the model will fall back on what it “knows” about the relationships between sounds and words it has learned from its training data.

All that being said, I don't disagree that you've found it to be useful! I think there's something to be said for making technology more accessible. However, I do think there are ethical concerns that need to be addressed, and that people who choose to use these tools should use them with caution. I think what you said in your previous post is well put:

However, when faced with clear evidence that challenges their beliefs, some individuals may react with frustration or even anger—not out of malice, but because it can be difficult to reconcile new truths with deeply held perspectives. This response is often tied to a natural human tendency to protect one's own sense of understanding. In moments like these, it’s important that we approach each other with patience, grace, and a heart that seeks truth in love.