In late 2017, we started SignalWire with a mission: Pioneer the transition of the mainstream world to Software-Defined Telecom.
Building on the back of over a decade of innovation with the FreeSWITCH platform and countless contributions to the Asterisk PBX before that, we are focused on ushering in a new era of telecommunications. The journey was a long and hard fight but we feel it was worth the pain so that today you can enjoy an experience we have been dreaming of for decades.
When computers and telephones meet
Back in the early 2000s not everyone in the mainstream was using a home computer yet and those who did have a computer were not always online. When people did go online it was often a temporary visit to check email and a few other things and then hang up. AOL was still a thing. Telephones were mostly copper pair and as boring as ever. PDAs and MP3 players flashed a glimpse of the future to come but they were mostly toys only for technophiles and execs to play on.
One of the first times I pondered the marriage of computers and telephones was when I heard about eFax in the late ’90s. I remember wondering how they get phones to turn the faxes into digital files and imagined how cool having that reverse modem bank could be for phone calls.
Others clearly had this same thought because suddenly there were some new obscure devices that could sample analog telephony into PC and those audio samples could be recorded to disk or bridged to another audio device and supposedly, the Internet.
I was immediately drawn to this. I was excited about the idea that I could make the PC on my desk into a super expensive answering machine. It worked really well, except when it didn’t (which was all the time) but that’s ok, it was amazing that it was even possible. I spent a lot of time researching how to mess with these devices and how I could get something more low level, like an open-source driver or control software, to make it possible to wield more power over these devices. The more I tried the more often my whole computer would lock up.
Tinkering until it works
The next step was trying to have a call with someone else for free! I would dial into the Internet with my modem then try to get my Internet Jack or creative VoIP blaster or whatever was cool back then to let me call my friends. (The friends I could have just called with the phone instead of using it for my modem of course). Lucky for me, ISDN and Cable modems were right around the corner and that would make my efforts much more fruitful, and logical since those friends got farther and farther away as the Internet opened the world to more communication.
Then came Asterisk. Holy Shit! I just plugged my old analog phone into the back of this Linux machine and now I have a dial tone? Who can I call? Screaming monkeys? Some lady named Allison who seems really happy that I called? This seems like a step in the right direction. This Asterisk thing is just screaming to be the core of my next genius product! I will hack on it and figure out how to modify it and add stuff to it and use it for things it was never meant to do. What could go wrong?
I spent a lot of time tinkering and eventually started making significant solutions from the endless hours digging into code and Linux and telco circuits signaling. I put a whole DS3 circuit worth of telephone calls (about 644) into an army of repurposed Asterisk servers and made our own provider service. The sheer load killed Asterisk every so often so I needed to design it so that when one machine died the calls moved down the circuit to the next one, ok not ideal but it worked!
Well, it turns out there is a steep learning curve to modifying, debugging and extending software written in C. One wrong move and the application terminates abruptly, taking all your calls and your product reputation with it. This was daunting but seemed worth it to push forward. We were so close to a really big first step in using the Internet for phone calls. Voice over IP as a movement was picking up but it still had a horrible reputation which was partially because it was unreliable and partially sour grapes from the big telcos trying to stave off the inevitable.
FreeSWITCH is born
Myself and a few other tried and true developers from the arcane world of IRC and hacking on C code decided: Let’s stop breaking Asterisk, it's not the right tool for the job and we might be making things worse trying to put a round peg in a square hole. Let’s make a new tool that is in the image of what we really want: true high-scale telephony in the digital world. We deliberated on how to design our new creation for almost 6 months, talking ourselves out of the idea at least twice. In the end, we had a cross-platform server software that changed names 3 times and took a whole year to build the first version but could swallow an entire 100mb line worth of Internet telephone calls and could melt any hardware telephone switch out there. This is how we ended up with FreeSWITCH.
The advent of FreeSWITCH helped Asterisk get back to its roots as a PBX. FreeSWITCH would focus on the future and Asterisk would continue to serve its core competency. The driving force in the adoption of Asterisk was still Telephony cards and using Asterisk as server software for those cards.
Telephony grows popular
Twilio showed up along the way and decided to build their platform out of Asterisk. Since Twilio only focused on the old world of low-quality 8khz audio and legacy PSTN access, Asterisk worked out well for them. That commodity service should continue to diminish in cost, which is great for consumers, and it’s readily available now from many companies which is a big milestone for the movement in general. Based on my experience in the past, I would say there are a lot of battle scars in the effort to make a solid commercial product on that code base, hats off.
Today, Asterisk has been consumed by Sangoma, a company in Canada who also makes Telephony cards. A hall of fame effort and a large part of our history, we are proud to have been part of this original step in the right direction.
FreeSWITCH sets the standard for telecom tools
For years to follow since we started FreeSWITCH, we took that new tool and nurtured and fostered it into a powerful platform designed to not only move high-density telephony traffic over IP but also to act as a development platform for terminating calls. This made things like voice menus, conferencing and call queuing happen at scale.
The big vision even then was that the whole world could communicate over this medium and it would mean amazing things for everyone, especially those who did not want to devote their careers to low-level complex underpinnings of software and Telephony but did want to yield limitless benefits. I remember having numerous personal connections to all the excited users trying to imagine a path forward on an idea they thought was impossible. Every step of the way, the path got more clear and the future got brighter.
Early on in the process of creating FreeSWITCH my vision for what would become SignalWire was already forming. I wanted to find a way to allow end users to have an instant experience to get up and running with Software-Defined Telecom resources and I wanted developers to have something to code against to modify that user experience without drowning them in complexity as some interfaces do. The first goal was to get a rock-solid stack on which to build the layers that would make things scale globally. I had a design in my head for what was to become RELAY since at least 2008. Taking baby steps towards that goal we produced what we could with the resources we have.
See my other blog about API in our DNA for more info on this developer API evolutionary track.
WebRTC takes shape
In 2011, the public-facing side of WebRTC started to emerge. It started out as an open source media stack that was once a closed commercial product and a lot of technical specs. Some were left over from the first drafts of SIP, the dominating method for Voice Over IP transport. The overarching goal was to try to create a new reality: Web browsers could become communication tools. When we looked at this new movement through the lens of FreeSWITCH, we saw that we had to modify our existing media stack to support these specs so we could be ready to be the receiving end of all the new use-cases originating from the browser.
By 2013 our first support for WebRTC was ready and it was amazing. We could bridge the old world with the new and we spent nearly 3 more years evolving with the rest of the community to bring what we know today as a stable mechanism for transporting audio, video and messaging over mobile apps and browsers (while providing a server side that could provide remote applications and key logic to support those clients.) There was still a long way to go with polishing and scaling so that it could be less painful to get up and running. Our real goal was to enable services for programmers of all skill levels and areas of interest.
Software Defined Telecom begins
In 2017 we looked back on everything we have accomplished and what those before us had inspired us to do and how we found our path towards the betterment of the Industry. The dawn of the age of Software Defined Telecom had begun. Open Source is in our roots and it helped us create the tool that really makes a difference in how we can scale our communications but there was still so much more to do and our grand vision still has not been fully realized.
The key problem before we started SignalWire was that it was still very difficult to deploy and build applications or a scalable network with this powerful technology. There are millions of code paths all governed by endless configuration options. Some of us, especially the original pioneers and adopters of the tech, were very well versed in the art of setup and configuration of complex voice and video services. The majority of people, however, find configuring FreeSWITCH or other VoIP tools (and then the servers on which they reside) to be a daunting task and distracting to their core goals.
SignalWire simplifies communications
We decided that the next stage of our Software-Defined Telecom story involves the vast majority of people in the world who are missing out on all the amazing things they could do if we succeed at our mission: Simplifying things so new programmers can command powerful communications tools with the simplest of interfaces. We want to make it possible for enterprises to deploy completely functional dedicated telecom networks and run calls, both voice and video, from any device. SignalWire takes a personal stake in making sure all of our customers can focus on what’s important to them and simplify the stuff they never need to know.
Software-Defined Telecom is so much more than small scale Internet Voice and Video communications. It's about expanding that scale to meet the incredible demands of the world. We have come far but there is much farther to go until anyone can command the power of communications in minutes and Enterprises can solve their countless problems including the integrations they dream of being able to do. SignalWire is dedicated to becoming the World’s Software-Defined Telecommunications Network.
More than legacy
That’s the main reason we do not base our business on the arbitrage of legacy services like lower quality legacy PSTN and SMS. We do provide those services for as low of a cost as possible because we are dedicated to splitting the savings with our customers and not focusing on insane markups. That way, our customers can afford to invest in what matters: next-generation services designed to empower them with the tools they need to communicate in the new era of cloud computing. We support the legacy APIs of other providers with LāML, the Legacy Antiquated Markup Language. This is how we have tackled the problem of code portability for those wanting to migrate apps and then enhance them later.
Join the community
Join us in our community at https://signalwire.community and talk to us. We listen! We are excited to change the way the world communicates and we look forward to serving you the best we can. We still believe in open source and all of our client tools are liberally licensed on our GitHub page at https://github.com/signalwire. Soon, we hope to have a build of FreeSWITCH there too. Also, visit https://signalwire.com for more info.
I hope in another 15-20 years we can have even more exciting things to look back on, and we will owe it all to you.