Ever built apps that you wouldn't want to use yourself?

When I was a junior app developer, I used to build chaotic user interfaces.

Sometimes when looking at those UIs, I used to think "who in the world would even want to use this? It looks awful".

Other times, there was just "something off" that I just couldn't point out.

While I used to get amazing polished designs from design team, my apps would not look even 20% as good.

I was aware of this problem, and to fix it I went down on a rabbit hole of research in which I came across concept of having a design system which transformed the way I build apps.

What is this amazing thing called Design System?

It's crucial to understand what a design system is to be able to understand why do we need it.

Design system is basically a centralized source of truth for yours and your teams design decisions. It tells you what colours to use and where? How many types of buttons the app will have? Will the cards in your list have shadows? All answers comes from a design system.

Here are some of the benefits of having a design system:

• Consistent UIs: Your interface will not have those weird gaps here and there for no reason. It will look and feel uniform across all devices.

• Rapid decisions: Design systems enforces a certain set of constraints to make your decisions easier, not harder. The more options you have, the more analysis-paralysis you encounter.

• Scalable Apps: As the app grows, a design system helps in reusing components rather than building from scratch.

• Focus on development: You no longer have to stress whether the button should be green or blue. Instead, you'll focus on what matters.

Tools & Libraries

While there are tons of React Native UI libraries out there, I use custom approach as I've had horrible experiences with most of them regarding performance and bugs.

The only library I rely on for my approach is react-native-size-matters.

Now before you scream "size doesn't matter!", let me assure you it does. Especially, when it comes to mobile apps.

You don't want your users opening your app, seeing a giant logo covering everything, and think "What in the ugly..." before they delete without even trying because your logo hid the button.

That's where react-native-size-matters helps. It makes your apps responsive by scaling your components to fit the device. So, no matter which device users have, your logo stays exactly where you put it.

Set up theme

One of the first thing I define is my core design tokens. These are the building blocks of my design system. These include color palettes, typography, spacings, and font sizes.

I do this by creating a theme.ts file with the following code:

import {moderateScale} from 'react-native-size-matters';

// after installing custom fonts:
export const FontFamily = {
  bold: 'Poppins-Bold',
  semibold: 'Poppins-SemiBold',
  medium: 'Poppins-Medium',
  regular: 'Poppins-Regular',
  thin: 'Poppins-Thin',
};

const colors = {
  primary100: '#2E2C5F',
  primary80: '#524DA0',
  primary60: '#736DDF',
  primary40: '#A09BFF',
  primary20: '#DCDAFF',

  secondary100: '#484A22',
  secondary80: '#858945',
  secondary60: '#D9DF6D',
  secondary40: '#F8FCA1',
  secondary20: '#FDFFD4',

  neutral100: '#131218',
  neutral90: '#1D1C25',
  neutral80: '#272631',
  neutral70: '#343341',
  neutral60: '#3E3D4D',
  neutral50: '#53526A',
  neutral40: '#757494',
  neutral30: '#9C9AC1',
  neutral20: '#CBC9EF',
  neutral10: '#E8E7FF',
  white: '#fff',
  black: '#222',

  error: '#E7002A',
  success: '#3EC55F',
  warning: '#FECB2F',
  info: '#157EFB',
};

const theme = {
  colors,
  fontSizes: {
    xxl: moderateScale(32),
    xl: moderateScale(28),
    lg: moderateScale(24),
    md: moderateScale(20),
    body: moderateScale(17),
    sm: moderateScale(14),
    xs: moderateScale(12),
    xxs: moderateScale(10),
    xxxs: moderateScale(8),
  },
  spacing: {
    none: 0,
    xxs: moderateScale(4),
    xs: moderateScale(8),
    md: moderateScale(12),
    lg: moderateScale(16),
    xl: moderateScale(20),
    xxl: moderateScale(24),
    xxxl: moderateScale(28),
  },
};

export default theme;

Creating Reusable Components

Once my design tokens are in place, I define some reusable components such as Box, Typography, and Input. These components adhere to the design tokens, ensuring consistency across the app.

For example here's how I create Box component:

import {
  View,
  type ViewProps,
  type FlexAlignType,
  type ViewStyle,
} from 'react-native';
import theme from '../styles/theme/theme';

export interface IBox extends ViewProps {
  backgroundColor?: keyof typeof theme.colors;
  p?: keyof typeof theme.spacing;
  pv?: keyof typeof theme.spacing;
  ph?: keyof typeof theme.spacing;
  pt?: keyof typeof theme.spacing;
  pb?: keyof typeof theme.spacing;
  pl?: keyof typeof theme.spacing;
  pr?: keyof typeof theme.spacing;
  m?: keyof typeof theme.spacing;
  mv?: keyof typeof theme.spacing;
  mh?: keyof typeof theme.spacing;
  mt?: keyof typeof theme.spacing;
  mb?: keyof typeof theme.spacing;
  ml?: keyof typeof theme.spacing;
  mr?: keyof typeof theme.spacing;
  gap?: number;
  flex?: number;
  flexDirection?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
  alignItems?: FlexAlignType;
  justifyContent?:
    | 'center'
    | 'flex-start'
    | 'flex-end'
    | 'space-between'
    | 'space-around'
    | 'space-evenly';
  rounded?: boolean;
}

export default function Box({
  backgroundColor,
  p,
  pv,
  ph,
  pt,
  pb,
  pr,
  pl,
  m,
  mv,
  mh,
  mt,
  mb,
  ml,
  mr,
  children,
  style,
  flex,
  alignItems,
  justifyContent,
  flexDirection = 'column',
  rounded = false,
  gap = undefined,
  ...rest
}: IBox) {
  const getMargin = () => {
    const obj: any = {};

    if (m) {
      obj.margin = theme.spacing[m];
      return obj;
    }
    if (mt) obj.marginTop = mt ? theme.spacing[mt] : 0;
    if (mb) obj.marginBottom = mb ? theme.spacing[mb] : 0;
    if (ml) obj.marginLeft = ml ? theme.spacing[ml] : 0;
    if (mr) obj.marginRight = mr ? theme.spacing[mr] : 0;
    if (mv) obj.marginVertical = theme.spacing[mv];
    if (mh) obj.marginHorizontal = theme.spacing[mh];
    return obj;
  };

  const getPadding = () => {
    const obj: any = {};

    if (p) {
      obj.padding = theme.spacing[p];
      return obj;
    }

    if (pt) obj.paddingTop = pt ? theme.spacing[pt] : 0;
    if (pb) obj.paddingBottom = pb ? theme.spacing[pb] : 0;
    if (pl) obj.paddingLeft = pl ? theme.spacing[pl] : 0;
    if (pr) obj.paddingRight = pr ? theme.spacing[pr] : 0;
    if (pv) obj.paddingVertical = theme.spacing[pv];
    if (ph) obj.paddingHorizontal = theme.spacing[ph];

    return obj;
  };

  const boxStyles: ViewStyle[] = [
    {
      backgroundColor: backgroundColor
        ? theme.colors[backgroundColor]
        : undefined,
      flex,
      justifyContent,
      alignItems,
      flexDirection,
      borderRadius: rounded ? 10 : 0,
      gap,
    },
    getMargin(),
    getPadding(),
    style,
  ];

  return (
    <View style={boxStyles} {...rest}>
      {children}
    </View>
  );
}

I use this newly created Box component as a replacement of View. It allows me to quickly style it through props (and give suggestions if you're using typescript) like so:

Here's an example of how I create Typography component which I use instead of React Native's Text component:

import React from 'react';
import {Text, type TextProps} from 'react-native';
import theme, {FontFamily} from '../styles/theme/theme';

export interface ITypography extends TextProps {
  size?: keyof typeof theme.fontSizes;
  color?: keyof typeof theme.colors;
  textAlign?: 'center' | 'auto' | 'left' | 'right' | 'justify';
  variant?: keyof typeof FontFamily;
}

export default function Typography({
  size,
  color,
  textAlign,
  children,
  style,
  variant,
  ...rest
}: ITypography) {
  return (
    <Text
      {...rest}
      style={[
        {
          color: color ? theme.colors[color] : theme.colors.white,
          textAlign,
          fontSize: size ? theme.fontSizes[size] : theme.fontSizes.body,
          fontFamily: variant ? FontFamily[variant] : FontFamily.regular,
        },
        style,
      ]}>
      {children}
    </Text>
  );
}

Here's a preview of how quickly I am able to add styles to my custom Typography component:

Custom useTheme hook

Instead of importing theme again and again, I make my code more readable by creating a custom useTheme hook which I call anywhere in the app to add styles that adhere with my theme.

In order to do this, I leverage React's Context API to pass my theme in the app.

I create a ThemeProvider.tsx file and inside define the ThemeContext and ThemeProvider to wrap my app component inside it. Here's the code:

import React, {type PropsWithChildren, createContext} from 'react';
import theme from './theme';

export const ThemeContext = createContext(theme);

export default function ThemeProvider({children}: PropsWithChildren) {
  return (
    <ThemeContext.Provider value={theme}>{children}</ThemeContext.Provider>
  );
}

Then, inside my App component:

export default function App() {
  return (
    <ThemeProvider>
      <AppNavigation />
    </ThemeProvider>
  );
}

Now that my entire app has access to ThemeContext, I create my useTheme hook:

import {useContext} from 'react';
import {ThemeContext} from '../styles/theme/ThemeProvider';

export default function useTheme() {
  const theme = useContext(ThemeContext);
  return theme;
}

Now I can access my theme anywhere by calling the useTheme hook like so:

const theme = useTheme();
// example usage:
theme.colors.primary100;
theme.spacing.md;
theme.fontSizes.lg;

Dark Mode

To implement dark mode, in the theme.ts file, I add another color palette containing the colors for dark mode.

export const darkTheme = {
  // define dark mode colors here keeping the keys same as the light mode only changing the values.
}

Then, in ThemeProvider, I simply check user settings and switch the theme like so:

import {useColorScheme} from 'react-native';

export default function ThemeProvider({children}: PropsWithChildren) {

const isDarkMode = useColorScheme() === 'dark';

  return (

    <ThemeContext.Provider value={isDarkMode ? darkTheme : theme}>{children}</ThemeContext.Provider>

  );

}

Conclusion

Following this clear structured approach has brought much needed clarity, consistency, and aesthetics in my app while also sped up my development speed by at least 10x since I no longer have to dwell over design decisions.

I encourage you to try this approach and let me know what you guys think in the comments. Maybe improve it a little bit eh?