# [Solved] Programmatically Lighten or Darken a hex color (or rgb, and blend colors)

Here is a function I was working on to programmatically lighten or darken a hex color by a specific amount. Just pass in a string like `"3F6D2A"` for the color (`col`) and a base10 integer (`amt`) for the amount to lighten or darken. To darken, pass in a negative number (i.e. `-20`).

The reason for me to do this was because of all the solutions I found, thus far, they seemed to over-complicate the issue. And I had a feeling it could be done with just a couple lines of code. Please let me know if you find any problems, or have any adjustments to make that would speed it up.

``````function LightenDarkenColor(col, amt) {
col = parseInt(col, 16);
return (((col & 0x0000FF) + amt) | ((((col >> 8) & 0x00FF) + amt) << 8) | (((col >> 16) + amt) << 16)).toString(16);
}

// TEST
console.log( LightenDarkenColor("3F6D2A",40) );``````

For Development use here is an easier to read version:

``````function LightenDarkenColor(col, amt) {
var num = parseInt(col, 16);
var r = (num >> 16) + amt;
var b = ((num >> 8) & 0x00FF) + amt;
var g = (num & 0x0000FF) + amt;
var newColor = g | (b << 8) | (r << 16);
return newColor.toString(16);
}

// TEST
console.log(LightenDarkenColor("3F6D2A", -40));``````

And finally a version to handle colors that may (or may not) have the “#” in the beginning. Plus adjusting for improper color values:

``````function LightenDarkenColor(col,amt) {
var usePound = false;
if ( col[0] == "#" ) {
col = col.slice(1);
usePound = true;
}

var num = parseInt(col,16);

var r = (num >> 16) + amt;

if ( r > 255 ) r = 255;
else if  (r < 0) r = 0;

var b = ((num >> 8) & 0x00FF) + amt;

if ( b > 255 ) b = 255;
else if  (b < 0) b = 0;

var g = (num & 0x0000FF) + amt;

if ( g > 255 ) g = 255;
else if  ( g < 0 ) g = 0;

return (usePound?"#":"") + (g | (b << 8) | (r << 16)).toString(16);
}
``````

OK, so now it’s not just a couple of lines, but it seems far simpler and if you’re not using the “#” and don’t need to check for colors out of range, it is only a couple of lines.

If not using the “#”, you can just add it in code like:

``````var myColor = "3F6D2A";
myColor = LightenDarkenColor(myColor,10);
thePlaceTheColorIsUsed = ("#" + myColor);
``````

I guess my main question is, am I correct here? Does this not encompass some (normal) situations?

## Solution #1:

Well, this answer has become its own beast. Many new versions, it was getting stupid long. Many thanks to all of the great many contributors to this answer. But, in order to keep it simple for the masses. I archived all the versions/history of this answer’s evolution to my github. And started it over clean on StackOverflow here with the newest version. A special thanks goes out to Mike ‘Pomax’ Kamermans for this version. He gave me the new math.

This function (`pSBC`) will take a HEX or RGB web color. `pSBC` can shade it darker or lighter, or blend it with a second color, and can also pass it right thru but convert from Hex to RGB (Hex2RGB) or RGB to Hex (RGB2Hex). All without you even knowing what color format you are using.

This runs really fast, probably the fastest, especially considering its many features. It was a long time in the making. See the whole story on my github. If you want the absolutely smallest and fastest possible way to shade or blend, see the Micro Functions below and use one of the 2-liner speed demons. They are great for intense animations, but this version here is fast enough for most animations.

This function uses Log Blending or Linear Blending. However, it does NOT convert to HSL to properly lighten or darken a color. Therefore, results from this function will differ from those much larger and much slower functions that use HSL.

jsFiddle with pSBC

github > pSBC Wiki

Features:

• Auto-detects and accepts standard Hex colors in the form of strings. For example: `"#AA6622"` or `"#bb551144"`.
• Auto-detects and accepts standard RGB colors in the form of strings. For example: `"rgb(123,45,76)"` or `"rgba(45,15,74,0.45)"`.
• Shades colors to white or black by percentage.
• Blends colors together by percentage.
• Does Hex2RGB and RGB2Hex conversion at the same time, or solo.
• Accepts 3 digit (or 4 digit w/ alpha) HEX color codes, in the form #RGB (or #RGBA). It will expand them. For Example: `"#C41"` becomes `"#CC4411"`.
• Accepts and (Linear) blends alpha channels. If either the `c0` (from) color or the `c1` (to) color has an alpha channel, then the returned color will have an alpha channel. If both colors have an alpha channel, then the returned color will be a linear blend of the two alpha channels using the percentage given (just as if it were a normal color channel). If only one of the two colors has an alpha channel, this alpha will just be passed thru to the returned color. This allows one to blend/shade a transparent color while maintaining the transparency level. Or, if the transparency levels should blend as well, make sure both colors have alphas. When shading, it will pass the alpha channel straight thru. If you want basic shading that also shades the alpha channel, then use `rgb(0,0,0,1)` or `rgb(255,255,255,1)` as your `c1` (to) color (or their hex equivalents). For RGB colors, the returned color’s alpha channel will be rounded to 3 decimal places.
• RGB2Hex and Hex2RGB conversions are implicit when using blending. Regardless of the `c0` (from) color; the returned color will always be in the color format of the `c1` (to) color, if one exists. If there is no `c1` (to) color, then pass `'c'` in as the `c1` color and it will shade and convert whatever the `c0` color is. If conversion only is desired, then pass `0` in as the percentage (`p`) as well. If the `c1` color is omitted or a non-`string` is passed in, it will not convert.
• A secondary function is added to the global as well. `pSBCr` can be passed a Hex or RGB color and it returns an object containing this color information. Its in the form: {r: XXX, g: XXX, b: XXX, a: X.XXX}. Where `.r`, `.g`, and `.b` have range 0 to 255. And when there is no alpha: `.a` is -1. Otherwise: `.a` has range 0.000 to 1.000.
• For RGB output, it outputs `rgba()` over `rgb()` when a color with an alpha channel was passed into `c0` (from) and/or `c1` (to).
• Minor Error Checking has been added. It’s not perfect. It can still crash or create jibberish. But it will catch some stuff. Basically, if the structure is wrong in some ways or if the percentage is not a number or out of scope, it will return `null`. An example: `pSBC(0.5,"salt") == null`, where as it thinks `#salt` is a valid color. Delete the four lines which end with `return null;` to remove this feature and make it faster and smaller.
• Uses Log Blending. Pass `true` in for `l` (the 4th parameter) to use Linear Blending.

### Code:

``````// Version 4.0
const pSBC=(p,c0,c1,l)=>{
let r,g,b,P,f,t,h,i=parseInt,m=Math.round,a=typeof(c1)=="string";
if(typeof(p)!="number"||p<-1||p>1||typeof(c0)!="string"||(c0[0]!='r'&&c0[0]!='#')||(c1&&!a))return null;
if(!this.pSBCr)this.pSBCr=(d)=>{
let n=d.length,x={};
if(n>9){
[r,g,b,a]=d=d.split(","),n=d.length;
if(n<3||n>4)return null;
x.r=i(r[3]=="a"?r.slice(5):r.slice(4)),x.g=i(g),x.b=i(b),x.a=a?parseFloat(a):-1
}else{
if(n==8||n==6||n<4)return null;
if(n<6)d="#"+d[1]+d[1]+d[2]+d[2]+d[3]+d[3]+(n>4?d[4]+d[4]:"");
d=i(d.slice(1),16);
if(n==9||n==5)x.r=d>>24&255,x.g=d>>16&255,x.b=d>>8&255,x.a=m((d&255)/0.255)/1000;
else x.r=d>>16,x.g=d>>8&255,x.b=d&255,x.a=-1
}return x};
h=c0.length>9,h=a?c1.length>9?true:c1=="c"?!h:false:h,f=this.pSBCr(c0),P=p<0,t=c1&&c1!="c"?this.pSBCr(c1):P?{r:0,g:0,b:0,a:-1}:{r:255,g:255,b:255,a:-1},p=P?p*-1:p,P=1-p;
if(!f||!t)return null;
if(l)r=m(P*f.r+p*t.r),g=m(P*f.g+p*t.g),b=m(P*f.b+p*t.b);
else r=m((P*f.r**2+p*t.r**2)**0.5),g=m((P*f.g**2+p*t.g**2)**0.5),b=m((P*f.b**2+p*t.b**2)**0.5);
a=f.a,t=t.a,f=a>=0||t>=0,a=f?a<0?t:t<0?a:a*P+t*p:0;
if(h)return"rgb"+(f?"a(":"(")+r+","+g+","+b+(f?","+m(a*1000)/1000:"")+")";
else return"#"+(4294967296+r*16777216+g*65536+b*256+(f?m(a*255):0)).toString(16).slice(1,f?undefined:-2)
}
``````

### Usage:

``````// Setup:

let color1 = "rgb(20,60,200)";
let color2 = "rgba(20,60,200,0.67423)";
let color3 = "#67DAF0";
let color4 = "#5567DAF0";
let color5 = "#F3A";
let color6 = "#F3A9";
let color7 = "rgb(200,60,20)";
let color8 = "rgba(200,60,20,0.98631)";

// Tests:

/*** Log Blending ***/
pSBC ( 0.42, color1 ); // rgb(20,60,200) + [42% Lighter] => rgb(166,171,225)
pSBC ( -0.4, color5 ); // #F3A + [40% Darker] => #c62884
pSBC ( 0.42, color8 ); // rgba(200,60,20,0.98631) + [42% Lighter] => rgba(225,171,166,0.98631)

pSBC ( 0.42, color2, "c" ); // rgba(20,60,200,0.67423) + [42% Lighter] + [Convert] => #a6abe1ac

// RGB2Hex & Hex2RGB Conversion Only (set percentage to zero)
pSBC ( 0, color6, "c" ); // #F3A9 + [Convert] => rgba(255,51,170,0.6)

// Blending
pSBC ( -0.5, color2, color8 ); // rgba(20,60,200,0.67423) + rgba(200,60,20,0.98631) + [50% Blend] => rgba(142,60,142,0.83)
pSBC ( 0.7, color2, color7 ); // rgba(20,60,200,0.67423) + rgb(200,60,20) + [70% Blend] => rgba(168,60,111,0.67423)
pSBC ( 0.25, color3, color7 ); // #67DAF0 + rgb(200,60,20) + [25% Blend] => rgb(134,191,208)
pSBC ( 0.75, color7, color3 ); // rgb(200,60,20) + #67DAF0 + [75% Blend] => #86bfd0

/*** Linear Blending ***/
pSBC ( 0.42, color1, false, true ); // rgb(20,60,200) + [42% Lighter] => rgb(119,142,223)
pSBC ( -0.4, color5, false, true ); // #F3A + [40% Darker] => #991f66
pSBC ( 0.42, color8, false, true ); // rgba(200,60,20,0.98631) + [42% Lighter] => rgba(223,142,119,0.98631)

pSBC ( 0.42, color2, "c", true ); // rgba(20,60,200,0.67423) + [42% Lighter] + [Convert] => #778edfac

// RGB2Hex & Hex2RGB Conversion Only (set percentage to zero)
pSBC ( 0, color6, "c", true ); // #F3A9 + [Convert] => rgba(255,51,170,0.6)

// Blending
pSBC ( -0.5, color2, color8, true ); // rgba(20,60,200,0.67423) + rgba(200,60,20,0.98631) + [50% Blend] => rgba(110,60,110,0.83)
pSBC ( 0.7, color2, color7, true ); // rgba(20,60,200,0.67423) + rgb(200,60,20) + [70% Blend] => rgba(146,60,74,0.67423)
pSBC ( 0.25, color3, color7, true ); // #67DAF0 + rgb(200,60,20) + [25% Blend] => rgb(127,179,185)
pSBC ( 0.75, color7, color3, true ); // rgb(200,60,20) + #67DAF0 + [75% Blend] => #7fb3b9

/*** Other Stuff ***/
// Error Checking
pSBC ( 0.42, "#FFBAA" ); // #FFBAA + [42% Lighter] => nullâ€ƒâ€ƒ(Invalid Input Color)
pSBC ( 42, color1, color5 ); // rgb(20,60,200) + #F3A + [4200% Blend] => nullâ€ƒâ€ƒ(Invalid Percentage Range)
pSBC ( 0.42, {} ); // [object Object] + [42% Lighter] => nullâ€ƒâ€ƒ(Strings Only for Color)
pSBC ( "42", color1 ); // rgb(20,60,200) + ["42"] => nullâ€ƒâ€ƒ(Numbers Only for Percentage)
pSBC ( 0.42, "salt" ); // salt + [42% Lighter] => nullâ€ƒâ€ƒ(A Little Salt is No Good...)

// Error Check Failsâ€ƒ(Some Errors are not Caught)
pSBC ( 0.42, "#salt" ); // #salt + [42% Lighter] => #a5a5a500â€ƒâ€ƒ(...and a Pound of Salt is Jibberish)

// Ripping
pSBCr ( color4 ); // #5567DAF0 + [Rip] => [object Object] => {'r':85,'g':103,'b':218,'a':0.941}
``````

The picture below will help show the difference in the two blending methods:

## Micro Functions

If you really want speed and size, you will have to use RGB not HEX. RGB is more straightforward and simple, HEX writes too slow and comes in too many flavors for a simple two-liner (IE. it could be a 3, 4, 6, or 8 digit HEX code). You will also need to sacrifice some features, no error checking, no HEX2RGB nor RGB2HEX. As well, you will need to choose a specific function (based on its function name below) for the color blending math, and if you want shading or blending. These functions do support alpha channels. And when both input colors have alphas it will Linear Blend them. If only one of the two colors has an alpha, it will pass it straight thru to the resulting color. Below are two liner functions that are incredibly fast and small:

``````const RGB_Linear_Blend=(p,c0,c1)=>{
var i=parseInt,r=Math.round,P=1-p,[a,b,c,d]=c0.split(","),[e,f,g,h]=c1.split(","),x=d||h,j=x?","+(!d?h:!h?d:r((parseFloat(d)*P+parseFloat(h)*p)*1000)/1000+")"):")";
return"rgb"+(x?"a(":"(")+r(i(a[3]=="a"?a.slice(5):a.slice(4))*P+i(e[3]=="a"?e.slice(5):e.slice(4))*p)+","+r(i(b)*P+i(f)*p)+","+r(i(c)*P+i(g)*p)+j;
}

var i=parseInt,r=Math.round,[a,b,c,d]=c.split(","),P=p<0,t=P?0:255*p,P=P?1+p:1-p;
return"rgb"+(d?"a(":"(")+r(i(a[3]=="a"?a.slice(5):a.slice(4))*P+t)+","+r(i(b)*P+t)+","+r(i(c)*P+t)+(d?","+d:")");
}

const RGB_Log_Blend=(p,c0,c1)=>{
var i=parseInt,r=Math.round,P=1-p,[a,b,c,d]=c0.split(","),[e,f,g,h]=c1.split(","),x=d||h,j=x?","+(!d?h:!h?d:r((parseFloat(d)*P+parseFloat(h)*p)*1000)/1000+")"):")";
return"rgb"+(x?"a(":"(")+r((P*i(a[3]=="a"?a.slice(5):a.slice(4))**2+p*i(e[3]=="a"?e.slice(5):e.slice(4))**2)**0.5)+","+r((P*i(b)**2+p*i(f)**2)**0.5)+","+r((P*i(c)**2+p*i(g)**2)**0.5)+j;
}

var i=parseInt,r=Math.round,[a,b,c,d]=c.split(","),P=p<0,t=P?0:p*255**2,P=P?1+p:1-p;
return"rgb"+(d?"a(":"(")+r((P*i(a[3]=="a"?a.slice(5):a.slice(4))**2+t)**0.5)+","+r((P*i(b)**2+t)**0.5)+","+r((P*i(c)**2+t)**0.5)+(d?","+d:")");
}
``````

PT

(P.s. If anyone has the math for another blending method, please share.)

## Solution #2:

I made a solution that works very nice for me:

``````function shadeColor(color, percent) {

var R = parseInt(color.substring(1,3),16);
var G = parseInt(color.substring(3,5),16);
var B = parseInt(color.substring(5,7),16);

R = parseInt(R * (100 + percent) / 100);
G = parseInt(G * (100 + percent) / 100);
B = parseInt(B * (100 + percent) / 100);

R = (R<255)?R:255;
G = (G<255)?G:255;
B = (B<255)?B:255;

var RR = ((R.toString(16).length==1)?"0"+R.toString(16):R.toString(16));
var GG = ((G.toString(16).length==1)?"0"+G.toString(16):G.toString(16));
var BB = ((B.toString(16).length==1)?"0"+B.toString(16):B.toString(16));

return "#"+RR+GG+BB;
}
``````

Example Lighten:

``````shadeColor("#63C6FF",40);
``````

Example Darken:

``````shadeColor("#63C6FF",-40);
``````

## Solution #3:

Here is a super simple one liner based on Eric’s answer

``````function adjust(color, amount) {
return '#' + color.replace(/^#/, '').replace(/../g, color => ('0'+Math.min(255, Math.max(0, parseInt(color, 16) + amount)).toString(16)).substr(-2));
}
``````

Examples:

``````adjust('#ffffff', -20) => "#ebebeb"
``````

## Solution #4:

I am adding my 2 cents here, a satisfyingly small combination of different answers:

``````const colorShade = (col, amt) => {
col = col.replace(/^#/, '')
if (col.length === 3) col = col[0] + col[0] + col[1] + col[1] + col[2] + col[2]

let [r, g, b] = col.match(/.{2}/g);
([r, g, b] = [parseInt(r, 16) + amt, parseInt(g, 16) + amt, parseInt(b, 16) + amt])

r = Math.max(Math.min(255, r), 0).toString(16)
g = Math.max(Math.min(255, g), 0).toString(16)
b = Math.max(Math.min(255, b), 0).toString(16)

const rr = (r.length < 2 ? '0' : '') + r
const gg = (g.length < 2 ? '0' : '') + g
const bb = (b.length < 2 ? '0' : '') + b

return `#\${rr}\${gg}\${bb}`
}

``````

accepts a color starting with `#` or not, with 6 characters or 3 characters.

example of use: `colorShade('#54b946', -40)`

Here is the output of 4 colors with 3 shades lighter and 3 shades darker for each of them (amount is a multiple of 40 here).

## Solution #5:

This is what I used based on your function. I prefer to use steps over percentage because it’s more intuitive for me.

For example, 20% of a 200 blue value is much different than 20% of a 40 blue value.

Anyways, here’s my modification, thanks for your original function.

``````function adjustBrightness(col, amt) {

var usePound = false;

if (col[0] == "#") {
col = col.slice(1);
usePound = true;
}

var R = parseInt(col.substring(0,2),16);
var G = parseInt(col.substring(2,4),16);
var B = parseInt(col.substring(4,6),16);

// to make the colour less bright than the input
// change the following three "+" symbols to "-"
R = R + amt;
G = G + amt;
B = B + amt;

if (R > 255) R = 255;
else if (R < 0) R = 0;

if (G > 255) G = 255;
else if (G < 0) G = 0;

if (B > 255) B = 255;
else if (B < 0) B = 0;

var RR = ((R.toString(16).length==1)?"0"+R.toString(16):R.toString(16));
var GG = ((G.toString(16).length==1)?"0"+G.toString(16):G.toString(16));
var BB = ((B.toString(16).length==1)?"0"+B.toString(16):B.toString(16));

return (usePound?"#":"") + RR + GG + BB;

}
``````

## Solution #6:

I tried your function and there was a little bug: If some final ‘r’ value is 1 digit only, the result comes up like: ‘a0a0a’ when the right value is ‘0a0a0a’, for example.

``````var rStr = (r.toString(16).length < 2)?'0'+r.toString(16):r.toString(16);
var gStr = (g.toString(16).length < 2)?'0'+g.toString(16):g.toString(16);
var bStr = (b.toString(16).length < 2)?'0'+b.toString(16):b.toString(16);

return (usePound?"#":"") + rStr + gStr + bStr;
``````

Maybe it’s not so nice but it do the work. Great function, BTW. Just what I needed. 🙂

## Solution #7:

have you thought about an rgb > hsl conversion? then just move the Luminosity up and down? thats the way I would go.

A quick look for some algorithms got me the following sites.

Javascript:
http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript

EDIT the above link is no longer valid. You can view git hub for the page source or the gist

Alternatively another StackOverflow question might be a good place to look.

Even though this is not the right choice for the OP the following is an approximation of the code I was originally suggesting. (Assuming you have rgb/hsl conversion functions)

``````var SHADE_SHIFT_AMOUNT = 0.1;

{
if(colorValue && colorValue.length >= 6)
{
var redValue = parseInt(colorValue.slice(-6,-4), 16);
var greenValue = parseInt(colorValue.slice(-4,-2), 16);
var blueValue = parseInt(colorValue.slice(-2), 16);

var hsl = rgbToHsl(redValue, greenValue, blueValue);
var rgb = hslToRgb(hsl[0], hsl[1], hsl[2]);
return "#" + rgb[0].toString(16) + rgb[1].toString(16) + rgb[2].toString(16);
}
return null;
}

{
if(colorValue && colorValue.length >= 6)
{
var redValue = parseInt(colorValue.slice(-6,-4), 16);
var greenValue = parseInt(colorValue.slice(-4,-2), 16);
var blueValue = parseInt(colorValue.slice(-2), 16);

var hsl = rgbToHsl(redValue, greenValue, blueValue);
var rgb = hslToRgb(hsl[0], hsl[1], hsl[2]);
return "#" + rgb[0].toString(16) + rgb[1].toString(16) + rgb[2].toString(16);
}
return null;
}
``````

This assumes:

1. You have functions `hslToRgb` and `rgbToHsl`.
2. The parameter `colorValue` is a string in the form #RRGGBB

Although if we are discussing css there is a syntax for specifying hsl/hsla for IE9/Chrome/Firefox.

## Solution #8:

I wanted to change a color to a specific brightness level – no matter what brightness the color was before – here’s a simple JS function that seems to work well, although I’m sure it could be shorter

``````function setLightPercentage(col: any, p: number) {
const R = parseInt(col.substring(1, 3), 16);
const G = parseInt(col.substring(3, 5), 16);
const B = parseInt(col.substring(5, 7), 16);
const curr_total_dark = (255 * 3) - (R + G + B);

// calculate how much of the current darkness comes from the different channels
const RR = ((255 - R) / curr_total_dark);
const GR = ((255 - G) / curr_total_dark);
const BR = ((255 - B) / curr_total_dark);

// calculate how much darkness there should be in the new color
const new_total_dark = ((255 - 255 * (p / 100)) * 3);

// make the new channels contain the same % of available dark as the old ones did
const NR = 255 - Math.round(RR * new_total_dark);
const NG = 255 - Math.round(GR * new_total_dark);
const NB = 255 - Math.round(BR * new_total_dark);

const RO = ((NR.toString(16).length === 1) ? "0" + NR.toString(16) : NR.toString(16));
const GO = ((NG.toString(16).length === 1) ? "0" + NG.toString(16) : NG.toString(16));
const BO = ((NB.toString(16).length === 1) ? "0" + NB.toString(16) : NB.toString(16));

return "#" + RO + GO + BO;}
``````

## Solution #9:

C# Version…
note that I am getting color strings in this format #FF12AE34, and need to cut out the #FF.

``````    private string GetSmartShadeColorByBase(string s, float percent)
{
if (string.IsNullOrEmpty(s))
return "";
var r = s.Substring(3, 2);
int rInt = int.Parse(r, NumberStyles.HexNumber);
var g = s.Substring(5, 2);
int gInt = int.Parse(g, NumberStyles.HexNumber);
var b = s.Substring(7, 2);
int bInt = int.Parse(b, NumberStyles.HexNumber);

var t = percent < 0 ? 0 : 255;
var p = percent < 0 ? percent*-1 : percent;

int newR = Convert.ToInt32(Math.Round((t - rInt) * p) + rInt);
var newG = Convert.ToInt32(Math.Round((t - gInt) * p) + gInt);
var newB = Convert.ToInt32(Math.Round((t - bInt) * p) + bInt);

return String.Format("#{0:X2}{1:X2}{2:X2}", newR, newG, newB);
}
``````

## Solution #10:

Your approach is ok 🙂 I simplify your shortest version a little (for saturation control look here)

``````(col,amt)=> (+('0x'+col)+amt*0x010101).toString(16).padStart(6,0)
``````

And version with # and color ranges checking

## Solution #11:

I just used the hex number preceded by ‘#’.

``````var x = 0xf0f0f0;
x=x+0xf00; //set this value as you wish programatically

``````

higher the number ..lighter the color

## Solution #12:

I needed it in C#, it may help .net developers

``````public static string LightenDarkenColor(string color, int amount)
{
int colorHex = int.Parse(color, System.Globalization.NumberStyles.HexNumber);
string output = (((colorHex & 0x0000FF) + amount) | ((((colorHex >> 0x8) & 0x00FF) + amount) << 0x8) | (((colorHex >> 0xF) + amount) << 0xF)).ToString("x6");
return output;
}
``````

## Solution #13:

The following method will allow you to lighten or darken the exposure value of a Hexadecimal (Hex) color string:

``````private static string GetHexFromRGB(byte r, byte g, byte b, double exposure)
{
exposure = Math.Max(Math.Min(exposure, 1.0), -1.0);
if (exposure >= 0)
{
return "#"
+ ((byte)(r + ((byte.MaxValue - r) * exposure))).ToString("X2")
+ ((byte)(g + ((byte.MaxValue - g) * exposure))).ToString("X2")
+ ((byte)(b + ((byte.MaxValue - b) * exposure))).ToString("X2");
}
else
{
return "#"
+ ((byte)(r + (r * exposure))).ToString("X2")
+ ((byte)(g + (g * exposure))).ToString("X2")
+ ((byte)(b + (b * exposure))).ToString("X2");
}

}
``````

For the last parameter value in GetHexFromRGB(), Pass in a double value somewhere between -1 and 1 (-1 is black, 0 is unchanged, 1 is white):

``````// split color (#e04006) into three strings
var r = Convert.ToByte("e0", 16);
var g = Convert.ToByte("40", 16);
var b = Convert.ToByte("06", 16);

GetHexFromRGB(r, g, b, 0.25);  // Lighten by 25%;
``````

## Solution #14:

How to simple shade color in PHP?

``````<?php

\$color = Str_Replace("#",Null,\$color);

\$r = Hexdec(Substr(\$color,0,2));
\$g = Hexdec(Substr(\$color,2,2));
\$b = Hexdec(Substr(\$color,4,2));

\$r = (Int)(\$r*(100+\$percent)/100);
\$g = (Int)(\$g*(100+\$percent)/100);
\$b = (Int)(\$b*(100+\$percent)/100);

\$r = Trim(Dechex((\$r<255)?\$r:255));
\$g = Trim(Dechex((\$g<255)?\$g:255));
\$b = Trim(Dechex((\$b<255)?\$b:255));

\$r = ((Strlen(\$r)==1)?"0{\$r}":\$r);
\$g = ((Strlen(\$g)==1)?"0{\$g}":\$g);
\$b = ((Strlen(\$b)==1)?"0{\$b}":\$b);

return (String)("#{\$r}{\$g}{\$b}");
}

``````

## Solution #15:

I made a port of the excellent xcolor library to remove its jQuery dependency. There are a ton of functions in there including lightening and darkening colors.

Really, converting hex to RGB is a completely separate function from lightening or darkening colors. Keep things DRY please. In any case, once you have an RGB color, you can just add the difference between the light level you want and the light level you have to each of the RGB values:

``````var lightness = function(level) {
if(level === undefined) {
return Math.max(this.g,this.r,this.b)
} else {
var roundedLevel = Math.round(level) // fractions won't work here
var levelChange = roundedLevel - this.lightness()

var r = Math.max(0,this.r+levelChange)
var g = Math.max(0,this.g+levelChange)
var b = Math.max(0,this.b+levelChange)

if(r > 0xff) r = 0xff
if(g > 0xff) g = 0xff
if(b > 0xff) b = 0xff

return xolor({r: r, g: g, b: b})
}
}

var lighter = function(amount) {
return this.lightness(this.lightness()+amount)
}
``````

See https://github.com/fresheneesz/xolor for more of the source.

## Solution #16:

I’ve long wanted to be able to produce tints/shades of colours, here is my JavaScript solution:

``````const varyHue = function (hueIn, pcIn) {
const truncate = function (valIn) {
if (valIn > 255) {
valIn = 255;
} else if (valIn < 0)  {
valIn = 0;
}
return valIn;
};

let red   = parseInt(hueIn.substring(0, 2), 16);
let green = parseInt(hueIn.substring(2, 4), 16);
let blue  = parseInt(hueIn.substring(4, 6), 16);
let pc    = parseInt(pcIn, 10);    //shade positive, tint negative
let max   = 0;
let dif   = 0;

max = red;

if (pc < 0) {    //tint: make lighter
if (green < max) {
max = green;
}

if (blue < max) {
max = blue;
}

dif = parseInt(((Math.abs(pc) / 100) * (255 - max)), 10);

return leftPad(((truncate(red + dif)).toString(16)), '0', 2)  + leftPad(((truncate(green + dif)).toString(16)), '0', 2) + leftPad(((truncate(blue + dif)).toString(16)), '0', 2);
} else {    //shade: make darker
if (green > max) {
max = green;
}

if (blue > max) {
max = blue;
}

dif = parseInt(((pc / 100) * max), 10);

return leftPad(((truncate(red - dif)).toString(16)), '0', 2)  + leftPad(((truncate(green - dif)).toString(16)), '0', 2) + leftPad(((truncate(blue - dif)).toString(16)), '0', 2);
}
};
``````

## Solution #17:

There is lack of support for colors starting from 00 ie “#000623” but here is the fix

``````function lightenDarkenColor(colorCode, amount) {
let usePound = false;

if (colorCode[0] == "#") {
colorCode = colorCode.slice(1);
usePound = true;
}
const num = parseInt(colorCode, 16);
let r = (num >> 16) + amount;

if (r > 255) {
r = 255;
} else if (r < 0) {
r = 0;
}

let b = ((num >> 8) & 0x00FF) + amount;

if (b > 255) {
b = 255;
} else if (b < 0) {
b = 0;
}

let g = (num & 0x0000FF) + amount;

if (g > 255) {
g = 255;
} else if (g < 0) {
g = 0;
}
let color = (g | (b << 8) | (r << 16)).toString(16);
while (color.length < 6){
color = 0 + color;
}
return (usePound ? '#' : '') + color;
}
``````

## Solution #18:

My version written in typescript:

``````function changeColorLightness(color: number, lightness: number): number {
return (Math.max(0, Math.min(((color & 0xFF0000) / 0x10000) + lightness, 0xFF)) * 0x10000) +
(Math.max(0, Math.min(((color & 0x00FF00) / 0x100) + lightness, 0xFF)) * 0x100) +
(Math.max(0, Math.min(((color & 0x0000FF)) + lightness, 0xFF)));
}
``````

explanation:

``````export function changeColorLightness(color: number, lightness: number): number {
const r = (color & 0xFF0000) / 0x10**4;
const g = (color & 0x00FF00) / 0x10**2;
const b = (color & 0x0000FF);

const changedR = Math.max(0, Math.min(r + lightness, 0xFF));
const changedG = Math.max(0, Math.min(g + lightness, 0xFF));
const changedB = Math.max(0, Math.min(b + lightness, 0xFF));

return (changedR * 0x10**4) + (changedG * 0x10**2) + changedB;
}
``````

usage:

``````changeColorLightness(0x00FF00, 0x50);
changeColorLightness(parseInt("#00FF00".replace('#',''), 16), 0x50);
changeColorLightness(0x00FF00, 127.5);
``````

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .