Why This Keeps Coming Up
Most people hit this problem when they're working with something like a graphics library, a physics simulation, or a GPS coordinate system. One moment everything is in radians because that's what the math expects, and the next they need to read the output in degrees so they can make sense of it or pass it to something that only understands degrees. You don't need a deep explanation of what a radian is. You need the conversion and you need to not mess it up in code. The formula itself is straightforward. Multiply the radian value by 180 and divide by . That's it. In decimal form that multiplier is approximately 57.2957795. So if you have 1 radian, you get roughly 57.3 degrees. If you have /2 radians, you get 90 degrees. If you've got a whole circle in radians (2), that's 360 degrees. The math doesn't change no matter how messy the number looks coming out. In practice I usually write it as a one-liner function in whatever language I'm using. Python looks like:
degrees = radians * 180 / math.pi Or you can use the built-in conversion if your language has one. Python's math.degrees(), JavaScript's value * 180 / Math.PI, C#'s value * 180.0 / Math.PI. Most modern languages ship with this. The question isn't whether you can find it, it's whether you remember to use it before you spend twenty minutes debugging why your rotation is completely wrong. Here's where people quietly mess up. They convert the input but forget the output. Or they convert once at the top of a function and then accidentally mix radians and degrees in the same calculation later. I ran into this a few years ago working on a particle system for a game prototype. The velocity angles were coming from a noise function that returned radians, but somewhere in the render pipeline I'd converted them to degrees and then fed them back into a sine function without converting back. The particles spiraled outward in a completely broken pattern and I spent most of a Tuesday staring at it. The fix was to keep everything in radians internally and only convert at the boundary where data left the simulation and entered the display layer. That's the pattern I follow now. Convert at the edges, not in the middle.
There's a second trap that's more subtle. Floating point precision. When you're converting very small radian values or values that are close to multiples of , you can end up with results that look wrong because of rounding. Like converting 0.0001 radians to degrees and getting something like 0.00572958 instead of the cleaner version you expect. It's not a bug in the formula. It's just how floating point works. If you're doing a lot of conversions in a tight loop and the accumulated error matters, you can precompute 180/ as a constant and reuse it instead of recalculating the division every time. Saves a tiny amount of cycles and keeps the rounding consistent across calls. Sometimes you need the reverse too, going from degrees back to radians. That's multiply by and divide by 180. The constant for that direction is roughly 0.017453293. Same principle. Keep track of which direction you're going and don't let the two flow into each other. For people who just want to do this once in a spreadsheet or a calculator, type the radian number, multiply by 180, divide by 3.14159265359, and you're done. Google will also do it for you if you search "convert 1.5 radians to degrees" directly in the search bar. It handles the conversion on the results page. Not elegant, but functional if you're not writing code.
Get the Full Details
The main thing to take away is that the conversion itself is trivial and the hard part is staying consistent about it. Pick one unit for your internal calculations, convert only when data enters or leaves that system, and verify your conversions with a known value like /2 mapping to 90. That catches mistakes fast before they cascade into something much harder to track down.
