A decade ago, most STEM students depended on textbooks, calculators, and expensive licensed software. Today, open source tools have made advanced learning resources available to anyone with an internet connection.

Many of these tools are powerful enough for professional researchers and software engineers, yet simple enough for students who are just getting started. They help with coding, data analysis, mathematics, technical writing, visualization, collaboration, and project management.

In this article, we'll look at seven open source tools that can help STEM students study more effectively, build projects faster, and develop industry-ready technical skills.

What We'll Cover:

• Why Open Source Tools Matter for STEM Students

• Jupyter Notebook for Interactive Learning

• VS Code for Programming and Technical Projects

• GeoGebra for Mathematics Visualization

• Git and GitHub for Collaboration

• Blender for Scientific and Engineering Visualization

• OBS Studio for Recording and Presentations

• How Open Source Tools Build Career Skills

• The Future of STEM Education

• Final Thoughts

Why Open Source Tools Matter for STEM Students

Open source software is more than just free software. It gives students access to the underlying code, community support, and the freedom to experiment without restrictions.

This matters because STEM education is becoming increasingly hands-on. Employers expect students to understand practical workflows, not just theory. Learning how to use modern tools early can make the transition into internships and engineering roles much easier.

Open source ecosystems also evolve quickly. Students can explore real-world technologies used in research labs, startups, and large engineering organizations. Many of these environments also rely on open-source automation tools to simplify development workflows and improve collaboration across technical teams.

Jupyter Notebook for Interactive Learning

One of the most important tools for STEM students is Jupyter Notebook.

Jupyter Notebook allows users to combine code, mathematical equations, visualizations, and notes inside a single interactive document. This makes it extremely useful for subjects like data science, physics, statistics, and machine learning.

A student can write Python code, run calculations, and immediately visualize the output using graphs or tables. Instead of switching between multiple applications, everything exists in one place.

For example, a physics student can simulate motion equations, while a statistics student can analyze datasets directly inside the notebook.

Jupyter is widely used in universities and research institutions because it supports experimentation and iterative learning.

VS Code for Programming and Technical Projects

Visual Studio Code has become one of the most popular development environments in the world. Although it is developed by Microsoft, it's built on open source technologies and supports a massive extension ecosystem.

For STEM students, VS Code is valuable because it supports nearly every major programming language. Whether you're learning Python, JavaScript, C++, or Rust, the editor provides debugging, syntax highlighting, terminal integration, and Git support in one interface.

Engineering students often work across multiple disciplines. A robotics student might write Python scripts, configure embedded systems, and document experiments all in the same environment.

VS Code also integrates well with Jupyter Notebook, making it an excellent all-in-one workspace for technical learning.

GeoGebra for Mathematics Visualization

Mathematics becomes easier when students can visualize concepts instead of memorizing formulas.

GeoGebra is an open source mathematics platform that helps students explore algebra, geometry, calculus, and statistics through interactive graphs and simulations.

Students can manipulate equations dynamically and observe how graphs change in real time. This creates a much deeper understanding of mathematical relationships.

Interactive visualisation tools are especially useful for students preparing for advanced mathematics courses. Popular teaching platforms like Brighterly who are known as a great precalculus tutor, use graphing platforms like GeoGebra to better understand trigonometric functions, transformations, and polynomial behaviour. The platform is also useful for individual teachers who want to create interactive lessons instead of relying entirely on static diagrams.

Git and GitHub for Collaboration

Version control is one of the most important technical skills students can learn.

Git is an open source version control system that helps developers track changes in code and collaborate efficiently. It is widely used across software engineering, data science, and research projects.

Students often lose work because they overwrite files or create confusing project versions. Git solves this problem by maintaining a complete history of changes.

When paired with GitHub, students can collaborate on projects, contribute to open source repositories, and build a public portfolio of technical work.

This is especially valuable for computer science students applying for internships or engineering roles. Recruiters frequently review GitHub profiles to evaluate coding ability and project experience.

Even students outside traditional software engineering fields benefit from Git. Researchers use it for reproducible experiments, while engineering teams use it to manage technical documentation and simulation code.

Blender for Scientific and Engineering Visualization

Most people associate Blender with animation and game design, but it's also a powerful tool for STEM applications.

Blender is an open source 3D modeling and rendering platform used in industries ranging from architecture to scientific visualization.

Engineering students can use Blender to create product prototypes, mechanical visualizations, and simulation renders. Biology students can build anatomical models, while physics students can visualize complex systems in three dimensions.

Visualization plays a major role in technical understanding. A well-designed 3D model can explain concepts that are difficult to communicate through text alone.

Blender also teaches valuable spatial reasoning and design skills that are increasingly useful in fields like robotics, manufacturing, and augmented reality.

OBS Studio for Recording and Presentations

Modern STEM learning is becoming more collaborative and content-driven.

Students now create tutorials, record presentations, explain coding projects, and participate in online learning communities. OBS Studio is an open source tool that allows users to record screens, stream presentations, and create technical demonstrations.

This is particularly useful for students building portfolios or preparing project walkthroughs.

For example, a software engineering student can record a demo of a web application, while a mathematics student can create video explanations of problem-solving methods.

OBS Studio is lightweight, flexible, and widely used by educators, developers, and technical creators.

How Open Source Tools Build Career Skills

One of the biggest advantages of open source tools is that they mirror real industry workflows.

Students aren't just learning academic concepts. They're learning systems used in professional engineering environments.

A student who understands Git, VS Code, Jupyter, and collaborative development practices already has exposure to modern software engineering workflows. Similarly, students using Blender or GeoGebra are developing visualization and analytical skills that transfer into technical careers.

Open source communities also encourage experimentation. Students can inspect source code, contribute fixes, participate in discussions, and learn directly from experienced developers around the world.

This creates a more active learning process than simply consuming tutorials.

The Future of STEM Education

STEM education is shifting toward project-based and interdisciplinary learning.

Students are expected to solve problems, communicate ideas clearly, and adapt to rapidly evolving technologies. Open source tools make this possible by lowering financial barriers and giving students access to professional-grade software.

The rise of artificial intelligence, data science, and remote collaboration has also increased the importance of technical self-learning. Students who can independently explore tools and build projects will have a significant advantage in both academics and industry.

The good news is that modern open source ecosystems make this easier than ever before. A student with a laptop and internet connection can now access tools that were once available only to large universities or research organizations.

Final Thoughts

The best STEM students aren't always the ones with the most expensive hardware or software. Often, they're the ones who learn how to use accessible tools creatively and consistently.

Platforms like Jupyter Notebook, VS Code, GeoGebra, LibreOffice, Git, Blender, and OBS Studio provide a strong foundation for technical learning across many disciplines.

More importantly, these tools encourage curiosity, experimentation, and practical problem-solving. Those skills matter far beyond the classroom.

As STEM education continues to evolve, students who embrace open source technology will be better prepared for research, engineering, software development, and the increasingly interdisciplinary future of technical work.

In the past year, frontier AI labs such as OpenAI, xAI, Anthropic, Meta, and Google have all released real-time voice services. Yet voice apps also have the highest requirements for latency, privacy, and customization. It’s difficult to have a one-size-fits-all voice AI solution.

In this article, we’ll explore how to use open-source technologies to create voice AI agents that utilize your custom knowledge base, voice style, actions, fine-tuned AI models, and run on your own computer.

What We’ll Cover:

• Prerequisites

• What it Looks Like

• Two Voice AI Approaches

• The Voice AI Orchestrator

  • Configure an ASR

  • Run and configure a VAD

  • Configure an LLM

  • Configure a TTS

  • Configure MCP and actions

• Local AI With LlamaEdge

• Conclusion

Prerequisites

You’ll need to have and know a few things to most effectively follow along with this tutorial:

• Access to a Linux-like system. Mac or Windows WSL suffice too.

• Be comfortable with command line (CLI) tools.

• Be able to run server applications on the Linux system.

• Have/get free API keys from Groq and ElevenLabs.

• Optional: be able to compile and build Rust source code.

• Optional: have/get an EchoKit device or assemble your own.

What it Looks Like

The key software component we will cover is the echokit_server project. It is an open-source agent orchestrator for voice AI applications. That means it coordinates services such as LLMs, ASR, TTS, VAD, MCP, search, knowledge/vector databases, and others to generate intelligent voice responses from user prompts.

The EchoKit server provides a WebSocket interface that allows compatible clients to send and receive voice data to and from it. The echokit_box project provides an ESP32-based firmware that can act as a client to collect audio from the user and play TTS-generated voice from the EchoKit server. You can see a couple of demos here. You can assemble your own EchoKit device or purchase one.

Of course, you can also use a pure software client that conforms to the echokit_server WebSocket interface. The project publishes a JavaScript web page that you can run locally to connect to your own EchoKit server as a reference.

In the rest of the article, I will discuss how it’s implemented and how to deploy the system for your own voice AI applications.

Two Voice AI Approaches

When OpenAI released its “realtime voice” services in October 2024, the consensus was that voice AI required “end-to-end” AI models. Traditional LLMs take text as input and then respond in text. The voice end-to-end models take voice audio data as input and respond in voice audio data as well. The end-to-end models could reduce latency since the voice processing, understanding, and generation are done in a single step.

But an end-to-end model is very difficult to customize. For example, it’s impossible to add your own prompt and knowledge to the context for each LLM request, or to act on the LLM's thinking or tool-call responses, or to clone your own voice for the response.

The second approach is to use an “agent orchestration” service to tie together multiple AI models, using one model’s output as the input for the next model. This allows us to customize or select each model and manipulate or supplement the model input at every step.

• The VAD model is used to detect conversation turns in the user's speech. It determines when the user is finished speaking and is now expecting a response.

• The ASR/STT model turns user speech into text.

• The LLM model generates a text response, including MCP tool calls.

• The TTS model turns the response text into voice.

The issue with multi-model and multi-step orchestration is that it can be slow. A lot of optimizations are needed for this approach to work well. For example, a useful technique is to utilize streaming input and output wherever possible. This way, each model doesn’t have to wait for the complete response from the upstream model.

The EchoKit server is a stream-everything, highly efficient AI model orchestrator. It is entirely written in Rust for stability, safety, and speed.

The Voice AI Orchestrator

The EchoKit server project is an open-source AI service orchestrator focused on real-time voice use cases. It starts up a WebSocket server that listens for streaming audio input and returns streaming audio responses.

You can build the echokit_server project yourself using the Rust toolchain. Or, you can simply download the pre-built binary for your computer.

# for x86 / AMD64 CPUs
curl -LO https://github.com/second-state/echokit_server/releases/download/v0.1.0/echokit_server-v0.1.0-x86_64-unknown-linux-gnu.tar.gz
unzip echokit_server-v0.1.0-x86_64-unknown-linux-gnu.tar.gz

# for arm64 CPUs
curl -LO https://github.com/second-state/echokit_server/releases/download/v0.1.0/echokit_server-v0.1.0-aarch64-unknown-linux-gnu.tar.gz
unzip echokit_server-v0.1.0-aarch64-unknown-linux-gnu.tar.gz

Then, run it as follows:

nohup ./echokit_server &

It reads the config.toml file from the current directory. At the top of the file, you can configure the port on which the WebSocket server listens. You can also specify a WAV file that is downloaded to the connected EchoKit client device as a welcome message.

addr = "0.0.0.0:8000"
hello_wav = "hello.wav"

Configure an ASR

When the EchoKit server receives the user's voice data, it first sends the data to an ASR service to convert it into text.

There are many compelling ASR models available today. The EchoKit server can work with any OpenAI-compatible API providers, such as OpenAI itself, x.ai, OpenRouter, and Groq.

In our example, we use Groq’s Whisper ASR service. Whisper is a state-of-the-art ASR model released by OpenAI. Groq provides specialized hardware chips to run it very fast. You will first get a free API key from Groq. Then, configure the ASR service as follows. Notice the “prompt” for the Whisper model. It is a tried-and-true prompt to reduce hallucination of the Whisper model.

[asr]
url = "https://api.groq.com/openai/v1/audio/transcriptions"
api_key = "gsk_XYZ"
model = "whisper-large-v3"
lang = "en"
prompt = "Hello\n你好\n(noise)\n(bgm)\n(silence)\n"

Run and configure a VAD

In order to carry out a voice conversation, participants must detect each other's intentions and speak only when a turn arises. VAD (Voice Activity Detection) is a specialized AI model used to detect activities and, in particular, when the speaker has finished and expects an answer.

In EchoKit, we have VAD detection on both the device and the server.

• Device-side VAD: It detects human language. The device ignores background noise, music, keyboard sounds, and dog barking. It only sends human voice to the server.

• Server-side VAD: It processes the audio stream in 100ms (0.1s) chunks. Once it detects that the speaker has finished, it sends all transcribed text to the LLM and starts waiting for the LLM’s response stream.

The server-side VAD is optional, since the device-side VAD can also generate “conversation turn” signals. But due to the limited computing resources on the device, adding the server-side VAD can dramatically improve the overall VAD performance.

We’re porting the popular Silero VAD project from Python to Rust, and creating the silero_vad_server project. Build the project as instructed. You can start the VAD server on your EchoKit server’s port 9094 as follows:

VAD_LISTEN=0.0.0.0:9094 nohup target/release/silero_vad_server &

You might be wondering: why port to Rust? While many AI projects are written in Python for ease of development, Rust applications are often much lighter, faster, and safer at deployment. So, we’ll leverage AI tools like RustCoder to port as much Python code as possible to Rust. The EchoKit software stack is largely written in Rust.

The VAD server is a WebSocket service that listens on port 9094. As we discussed, the EchoKit server will stream audio to this WebSocket and stop the ASR when a conversation turn is detected. Therefore, we’ll add the VAD service to the EchoKit server’s ASR config section in config.toml.

[asr]
url = "https://api.groq.com/openai/v1/audio/transcriptions"
api_key = "gsk_XYZ"
model = "whisper-large-v3"
lang = "en"
prompt = "Hello\n你好\n(noise)\n(bgm)\n(silence)\n"
vad_realtime_url = "ws://localhost:9094/v1/audio/realtime_vad"

Configure an LLM

Once the ASR service transcribes the user's voice into text, the next step in the pipeline is the LLM (Large Language Model). It’s the AI service that actually “thinks” and generates an answer in text.

Again, the EchoKit server can work with any OpenAI-compatible API providers for LLMs, such as OpenAI itself, x.ai, OpenRouter, and Groq. Since the voice service is highly sensitive to speed, we’ll choose Groq again. Groq supports a number of open-source LLMs. We’ll choose the gpt-oss-20b model released by OpenAI.

[llm]
llm_chat_url = "https://api.groq.com/openai/v1/chat/completions"
api_key = "gsk_XYZ"
model = "openai/gpt-oss-20b"
history = 20

The “history” field indicates how many messages should be kept in the context. Another crucial feature of an LLM application is the “system prompt,” where you instruct the LLM how it should “behave.” You can specify the system prompt in the EchoKit server config as well.

[[llm.sys_prompts]]
role = "system"
content = """
You are a comedian. Engage in lighthearted and humorous conversation with the user. Tell jokes when appropriate.

"""

Since Groq is very fast, it can process very large system prompts in under one second. You can add a lot more context and instructions to the system prompt. For example, you can give the application “knowledge” about a specific field by putting entire books into the system prompt.

Configure a TTS

Finally, once the LLM generates a text response, the EchoKit server will call a TTS (text to speech) service to convert the text into voice and stream it back to the client device.

While Groq has a TTS service, it’s not particularly compelling. ElevenLabs is a leading TTS provider that offers hundreds of voice characters. It can express emotions and supports easy voice cloning. In the config below, you’ll put in your ElevenLabs API key and select a voice.

[tts]
platform = "Elevenlabs"
token = "sk_xyz"
voice = "VOICE-ID-ABCD"

The ElevenLabs TTS models and API services are all great, but they are not open-source. A very compelling open-source TTS, known as GPT-SoVITS, is also available.

You can port GPT-SoVITS from Python to Rust and create an open-source API server project called gsv_tts. It allows easy cloning of any voice. You can run a gsv_tts API server by following its instructions. Then, you can configure the EchoKit server to stream text to it and receive streaming audio from it.

[tts]
platform = "StreamGSV"
url = "http://gsv_tts.server:port/v1/audio/stream_speech"
speaker = "michael"

Configure MCP and actions

Of course, an “AI agent” is not just about chatting. It is about performing actions on specific tasks. For example, the “US civics test prep” use case, which I shared as an example video at the beginning of this article, requires the agent to get exam questions from a database, and then generate responses that guide the user toward the official answer. This is accomplished using LLM tools and actions.

• The LLM detects that the user is requesting a new question.

• Instead of responding in natural language, it responds with a JSON structure that instructs the agent to "get a new question and answer."

• The EchoKit server intercepts this JSON response and retrieves the question and answer from a database.

• The EchoKit server sends the question and answer back to the LLM.

• The LLM formulates a natural language response based on the question and answer.

• The EchoKit server generates a voice response using its TTS service.

As you can see, the EchoKit server needs to perform a few extra steps behind the scenes before it responds in voice. The EchoKit server leverages the MCP protocol for this. The function to look up questions and answers is provided by an open-source MCP server called ExamPrepAgent.

The MCP protocol standardizes the tools and functions for LLMs to call. There are many MCP servers available for all kinds of different tasks. ExamPrepAgent is just one of them.

We are running this MCP server on port 8003. With the MCP server up and running, you only need to add the following configuration to EchoKit server’s config.toml.

[[llm.mcp_server]]
server = "http://localhost:8003/mcp"
type = "http_streamable"

With MCP integration, the EchoKit AI agent can now perform actions. It can call APIs to send messages, make payments, or even turn electronic devices on or off.

Local AI With LlamaEdge

You’ve now seen the open-source EchoKit device working with the open-source EchoKit server to understand and respond to users in voice. But the AI models we use, while also open-source, run on commercial cloud providers. Can we run AI models using open-source technologies at home?

LlamaEdge is an open-source, cross-platform API server for AI models. It supports many mainstream LLM, ASR, and TTS models across Linux, Mac, Windows, and many CPU/GPU architectures. It’s perfect for running AI models on home or office computers. It also provides OpenAI-compatible API endpoints, which makes them very easy to integrate into the EchoKit server.

To install LlamaEdge and its dependencies, run the following shell command. It will detect your hardware and install the appropriate software that can fully take advantage of your GPUs (if any).

curl -sSf https://raw.githubusercontent.com/WasmEdge/WasmEdge/master/utils/install_v2.sh | bash -s

Then, download an open-source LLM model. I am using Google's Gemma model as an example.

curl -LO https://huggingface.co/second-state/gemma-3-4b-it-GGUF/resolve/main/gemma-3-4b-it-Q5_K_M.gguf

Download the cross-platform LlamaEdge API server.

curl -LO https://github.com/second-state/LlamaEdge/releases/latest/download/llama-api-server.wasm

Start an LLamaEdge API server with the Google Gemma LLM model. by default, it listens on localhost port 8080.

wasmedge --dir .:. --nn-preload default:GGML:AUTO:gemma-3-4b-it-Q5_K_M.gguf llama-api-server.wasm -p gemma-3

Test the OpenAI compatible API on that server.

curl -X POST http://localhost:8080/v1/chat/completions \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{"messages":[{"role":"system", "content": "You are a helpful assistant. Try to be as brief as possible."}, {"role":"user", "content": "Where is the capital of Texas?"}]}'

Now, you can add this local LLM service to your EchoKit server configuration.

[llm]
llm_chat_url = "http://localhost:8080/v1/chat/completions"
api_key = "NONE"
model = "default"
history = 20

The LlamaEdge project supports more than LLMs. It runs the Whisper ASR model and the Piper TTS model as OpenAI-compatible API servers as well.

Conclusion

The voice AI agent software stack is complex and deep. EchoKit is an open-source platform that ties together and coordinates all those components. It provides a good vantage point for us to learn about the entire stack.

I can’t wait to see what you build!

But what does STEM mean, exactly? It turns out that the answer is a bit more complicated than it seems at first glance.

In this article we'll cover what STEM means, why it's important, and some common approaches for STEM education in the classroom.

What is STEM?

STEM stands for Science, Technology, Engineering, and Mathematics. It's a broad term that generally refers to a curriculum that increases students' exposure to and proficiency in each subject.

However, science, technology, engineering, and mathematics are all vast disciplines. Because of this, there are several ways to define STEM, depending on the context it's used in.

For example, the National Science Foundation's definition of STEM also includes social sciences like psychology and economics, along with more typical branches like chemistry. This broader definition of STEM is what most schools and organizations follow.

But the Department of Homeland Security mostly considers natural sciences (biology, chemistry), and formal sciences (mathematics, statistics) in their definition of STEM. Some social sciences like economics are instead grouped with arts and humanities.

The acronym STEAM is also increasingly used, which is a variation of STEM that includes art as one of the core subjects. Art, in this case, can include language arts, design, visual arts, and other humanities.

Why is STEM important?

STEM is all around us, and affects every aspect of modern life. Just about every job requires STEM-related skills, whether it be using a computer or a soft skill like critical thinking or problem solving.

Like the definition of STEM itself, whether or not there's a STEM crisis is up for debate.

According to the Bureau of Labor Statistics (BLS), there's both a shortage and a surplus of STEM workers, depending on which discipline (electrical engineering, biomedical engineering, and so on) or job market (academic or private) you look at.

Still, the BLS projects that employment in computer and IT related fields will "grow 11 percent from 2019 to 2029, much faster than the average for all occupations".

Most of these new jobs are expected to come from an ever increasing demand for information security and cloud computing experts.

Whether or not there's a STEM shortage now or will be one in the future, many governments seem to agree that STEM education is worth investing in.

STEM in the classroom

You might be tired of hearing this, but STEM education can vary widely between countries, and even neighboring school districts.

Currently in the US, STEM education generally takes an integrated approach, where subjects are taught in unison rather than in separate class periods. Many states follow the Next Generation Science Standards, which place an emphasis on a hands-on, collaborative, student led approach to learning.

STEM education can begin as early as kindergarten, and may or may not require prior knowledge or involve students interacting directly with tech devices.

For example, a fourth grade lesson about algorithms could focus on more general computational thinking and logic rather than programming itself.

An unplugged activity to teach algorithms could be as simple as having groups of students create a necklace out of 5 different snacks. First, they draw a repeating pattern of snacks on a worksheet – cookie, chip, cereal, chip cookie, chip, cereal, etc.

After writing the "algorithm" for their necklace, they can build them with their group members using real snacks:

Students in South Korea learning about basic algorithms

Once finished, students could present the algorithm they used and eat their snacks.

A student wearing their completed snack necklace

For slightly older or more advanced students, the activity could begin by writing a list of detailed instructions: Open the snacks, get some string, unravel some string, cut the string, take one cookie, place the cookie down, and so on.

Then rather than make the necklace themselves, they could read their algorithm to another group member, who has to follow every instruction literally. If there's a bug preventing them from finishing the necklace, both students can work together to debug the algorithm and revise the steps.

But this is just one simple example. Educators around the world are constantly coming up with innovative ways to teach fundamental STEM concepts, even without the use of technology.

In summary

STEM can mean several different things depending on the context. But generally it's a broad term that refers to education or jobs that focus on science, technology, engineering, math, and sometimes art.

Hopefully now you have a better understanding of STE(A)M, and what it means for education and jobs in the future.

Technological innovations, like those from Boston Dynamics, offer a glimpse of exciting growth and change in the near future! Science, technology, engineering, and math (STEM) are growing in many ways. New technologies drive change in traditional industries, stimulate job growth, and revolutionize education.

From advanced research to elementary-school classrooms, our world is changing as technology becomes more prevalent.

_Photo by [Unsplash](https://unsplash.com/@nicetomeetyou?utm_source=medium&utm_medium=referral" rel="noopener" target="_blank" title="">Frank Wang on <a href="https://unsplash.com?utm_source=medium&utm_medium=referral" rel="noopener" target="blank" title=")

The Education Commission of the States (ECS) has reported that STEM related industries will experience 13% job growth from 2017 to 2027. Within that category, computer related industries will grow the most at 14%. In comparison, the average growth is expected to be 9%.

Median hourly earnings are $38.85 for STEM-related careers, compared to the $19.30 average. That’s a difference of over $40,000 in yearly income assuming a 40-hour work week. Unemployment is also half of the average (2.2% vs. 5.5%).

This all seems great! Fantastic job growth, high pay, and low unemployment. One key challenge to rain on this STEM parade is that many of those jobs could go unfilled in the future. In manufacturing alone, 3.5 million jobs will be needed by 2025, with nearly 2 million going unfilled.

_Photo by [Unsplash](https://unsplash.com/@_louisreed?utm_source=medium&utm_medium=referral" rel="noopener" target="_blank" title="">Louis Reed on <a href="https://unsplash.com?utm_source=medium&utm_medium=referral" rel="noopener" target="blank" title=")

The most commonly cited cause for this disparity is that workers will not be qualified enough to fill those roles. This leads us to wonder, what can be done to prepare workers for those jobs?

The demand for STEM education is understood by parents and students. 90% of students expect their future job will require some computer science knowledge. 85% of parents agree. Parents from low-income families ($54,000 or less yearly income) are twice as likely to find computer science more important than required courses.

Despite the demand from industry, students, and parents, 47% of principals reported their schools don’t offer coding courses. 53% don’t offer robotics. 44% of principals state a lack of teachers is why they don’t offer computer science. Of those principals, 40% state there is a teacher available in their schools who could teach computer science.

Refer to the table below for other reasons Computer Science isn’t offered:

Source: Google — Searching for Computer Science

Traditional education has done many great things in preparing students for the future, but has struggled in many ways. Notably, an over-emphasis on testing is a barrier to coding and other STEM courses. We may have to look outside the classroom for a solution.

Community-driven and open-source movements have revolutionized many industries. Being open-source means that the software, hardware, or whatever it might be is freely available and can be redistributed or modified. This allows information to be shared for the benefit of all.

Many open-source projects are created as hundreds of individuals work together to create a useful tool. Wikipedia is an example common to most of us.

Many companies drive astounding impact by contributing to open source. Below are a few companies (and some of their projects):

• GitHub
• Google (Android, TensorFlow, Chromium, Dart, Go)
• Linux
• Microsoft (Visual Studio Code, .NET dev tools, TypeScript)
• Automattic — Creators of WordPress

Let’s analyze two organizations that are teaching STEM through community and open-source.

freeCodeCamp

freeCodeCamp stands at the forefront of many organizations who teach coding. Founded in 2014 by Quincy Larson, freeCodeCamp has experienced outstanding growth. Highlighted below are a few key stats:

• 1 billion user minutes across all their platforms. That’s 2000 years!
• More visitors than CodeAcademy (which has a $47 million valuation)
• More visitors than Udacity (which has a $1 billion valuation)
• 54,500 Alumni with thousands now working in computer related industries
• Curriculum translated into Arabic, Chinese, Portuguese, Russian, and Spanish

It’d be easy to assume freeCodeCamp had hundreds of employees and was heavily funded! Actually, it’s quite the opposite. As of December 2018, freeCodeCamp has 5 employees and an operating budget of $200,000. It is a 501(c)(3) non-profit.

For more info on freeCodeCamp, check out this medium post.

How can 5 people do all that? Well, to put it simply, they don’t. At least not alone. Over 650 volunteers contribute to all that growth! Many graduates (and current students) use their newly acquired knowledge to give back.

Through Open Source for Good, freeCodeCamp also helps their students contribute to other open source or non profit organizations.

Although most users are adults, an increasing number of educators are using it. freeCodeCamp is adding a classroom mode and tools for study groups as donations and volunteering increases!

freeCodeCamp is educating thousands at home or in the classroom. People are learning then giving back, driving viral growth for this amazing organization. Following this model, we’re going to look at Khan Academy!

Khan Academy

Another fantastic example of community-driven change is more widely known: Khan Academy.

To briefly sum up their story, Sal Khan started tutoring family members who were struggling with science and math. As more family asked for his help, he posted videos on YouTube. He also created a website where they could do practice problems. More and more people found his resources. He was soon noticed by Bill Gates and Google.

Backed by a passionate community, Khan Academy began to reach more and more people. Through volunteer content creators and translators, they now reach hundreds of thousands of students in over 100 countries.

According to Sal Khan, Khan Academy was never designed to replace traditional classroom education. It is meant to supplement it by providing tools for teachers and students. Machine learning can create individualized and effective learning plans by analyzing data from students quizzes and Khan Academy practice. Teachers, now equipped with these plans, can better concentrate their efforts on each student!

A few stats about Khan Academy from their website:

• Students who complete 60% of their grade-level math on Khan Academy experience 1.8 times the expected growth on the NWEA MAP Test, a popular assessment test
• 64% of first-generation college students reported Khan Academy was meaningful to their education (164 surveyed)

Check out this Google Talk to learn more about this wonderful organization!

By empowering individuals through accessible resources, real change can be achieved. As communities develop around similar beliefs and goals, thousands are taught and are then able to teach.

This process of learning and giving back is key to educating future generations. Everyone, everywhere has the potential to learn difficult concepts, given the right community and resources.

We can help make those resources globally accessible by donating to these communities. Donations don’t have to be financial. By giving our time, talent, and energy, we can support open-source and community-driven organizations that are causing real global change.

I have been personally impacted by both of these organizations. I learned to code primarily through freeCodeCamp. I now enjoy a fulfilling job doing web development. I give back by translating resources in Spanish. We all have unique and valuable skills we can use to contribute!

Thanks for reading! In my spare time I write about education and cool technology. I also develop educational resources for robotics.

Check them out on my website or follow me on Twitter!