Hex to UIColor Converter

You have a brand shade from a designer's style sheet and an iOS screen waiting for it, so you need the right color in code, not a guess. The Hex to UIColor Converter reads a hex color and hands back the matching UIColor initializer for Swift, Objective-C or Xamarin, which saves iOS developers from splitting digits by hand and keeps every channel exact. This guide explains how the conversion works, walks through a full example, and gives you a Swift extension you can paste into your own project.

How the Hex to UIColor Converter Turns a Hex Color Code into Swift

A hex color code is a compact way to write three or four color channels in hexadecimal, a base-16 number system. UIColor, Apple's color class, wants the same information as floating-point values. The converter bridges that gap in three steps: it splits the digits into channel pairs, turns each pair into a decimal, and divides by 255 so every channel lands between 0 and 1. The result is a UIColor syntax string that is ready to use in your code. The fastest way to find a plausible Pantone name for a design color is to paste its hex value into the hex to pantone converter.

Reading #RRGGBB and #RRGGBBAA in Base-16

A six-digit #RRGGBB value holds the red, green and blue channels as two digits each. Each digit runs from 0 to F, so a pair covers 0 to 255. An 8-digit #RRGGBBAA value adds a fourth pair for opacity. The three-digit shorthand such as #F80 doubles each digit, so it expands to #FF8800. Knowing which form you hold matters, because an 8-digit string with the opacity pair first will be read differently by different tools.

Why RGBA Components Run from 0 to 1

UIColor stores its RGBA components as CGFloat fractions rather than whole numbers, and it does that inside a device color space that the system manages for you. That is why 255 never appears in a UIColor call: full red is 1.0 and no red is 0.0. The alpha channel follows the same rule, so 1.0 is fully opaque and 0.0 is invisible.

Hex String Parsing in a Swift Extension

If you would rather convert at runtime, for example when colors arrive from a server, add a Swift extension that does the parsing for you. This one accepts a leading #, the three-digit shorthand, and six or eight digits, and it returns nil for anything else.

extension UIColor {
    convenience init?(hexColor: String) {
        var digits = hexColor.trimmingCharacters(in: .whitespaces)
        if digits.hasPrefix("#") { digits.removeFirst() }
        if digits.count == 3 { digits = digits.map { "\($0)\($0)" }.joined() }
        if digits.count == 6 { digits += "FF" }
        guard digits.count == 8 else { return nil }
        var packed: UInt64 = 0
        guard Scanner(string: digits).scanHexInt64(&packed) else { return nil }
        let r = CGFloat((packed >> 24) & 0xFF) / 255
        let g = CGFloat((packed >> 16) & 0xFF) / 255
        let b = CGFloat((packed >> 8) & 0xFF) / 255
        let a = CGFloat(packed & 0xFF) / 255
        self.init(red: r, green: g, blue: b, alpha: a)
    }
}

Handling the #RGB Shorthand and Bad Input

The method is a failable initializer, declared as a convenience init so it can delegate to the standard one. The Scanner reads the digits as a single number, and the shifts pull out one byte per channel. A string that is not valid hexadecimal, or has the wrong length, makes the scan fail and returns nil, so your app never draws a broken shade. Call it like this: let overlay = UIColor(hexColor: "#E8590CCC").

Hex Color Values in UIKit and SwiftUI

The same hex string works across Apple's frameworks. In UIKit you assign the result to backgroundColor or tintColor. In SwiftUI, wrap it with Color(uiColor:) and the converted value drops straight into a view. Colors set through Interface Builder or an asset catalog use the same RGBA components, so a value you convert here will match what Xcode shows in its color panel. For a native iOS app, that consistency is what keeps the interface looking the same on every screen.

Convert a Hex Color to a UIColor Without Mistakes

Most errors come from the input, not the math. When you convert a hex color to a UIColor, check three things before you trust the output. First, confirm the hexadecimal color really has 3, 6 or 8 digits; a stray character or a missing digit produces a different shade or no shade at all. Second, decide whether the trailing pair is opacity, because a six-digit hex code is always fully opaque. Third, keep the casing consistent: e8590c and E8590C are the same color, but mixed casing in a shared file makes review harder.

The converter handles the same checks for you, and its UIColor format uses four decimals, which is more than the eye can tell apart on a Retina display. If you are processing many hex strings to UIColor values at once, such as a whole palette from a design file, run the Scanner based extension above in a loop instead of pasting each one. The Scanner reads each string in a single pass, so a palette of fifty entries costs nothing noticeable at launch. Teams that treat hex color to UIColor conversion as a one-time import, rather than something typed by hand, rarely ship an off-brand shade.

Store each converted UIColor as a named constant and reuse it. The same logo orange has to match across digital design files, the marketing site and the app, and web design teams usually quote only the hex value, so one converted branding constant keeps the shade identical wherever it appears.