diff --git a/libs/ui/widgets/kis_color_input.h b/libs/ui/widgets/kis_color_input.h
--- a/libs/ui/widgets/kis_color_input.h
+++ b/libs/ui/widgets/kis_color_input.h
@@ -37,7 +37,13 @@
 {
     Q_OBJECT
 public:
-    KisColorInput(QWidget* parent, const KoChannelInfo*, KoColor* color, KoColorDisplayRendererInterface *displayRenderer = KoDumbColorDisplayRenderer::instance());
+    KisColorInput(QWidget* parent, const KoChannelInfo*, KoColor* color, KoColorDisplayRendererInterface *displayRenderer = KoDumbColorDisplayRenderer::instance(), bool usePercentage = false);
+    inline bool usePercentage() const {
+        return m_usePercentage;
+    }
+    inline void setPercentageWise(bool val) {
+        m_usePercentage = val;
+    }
 protected:
     void init();
     virtual QWidget* createInput() = 0;
@@ -48,18 +54,22 @@
     KoColor* m_color;
     KoColorSlider* m_colorSlider;
     KoColorDisplayRendererInterface *m_displayRenderer;
+    bool m_usePercentage;
 };
 
 class KRITAUI_EXPORT KisIntegerColorInput : public KisColorInput
 {
     Q_OBJECT
 public:
-    KisIntegerColorInput(QWidget* parent, const KoChannelInfo*, KoColor* color, KoColorDisplayRendererInterface *displayRenderer = KoDumbColorDisplayRenderer::instance());
+    KisIntegerColorInput(QWidget* parent, const KoChannelInfo*, KoColor* color, KoColorDisplayRendererInterface *displayRenderer = KoDumbColorDisplayRenderer::instance(), bool usePercentage = false);
 protected:
     QWidget* createInput() override;
 public Q_SLOTS:
     void setValue(int);
     void update();
+private Q_SLOTS:
+    void onColorSliderChanged(int);
+    void onNumInputChanged(int);
 private:
     KisIntParseSpinBox* m_intNumInput;
 };
@@ -69,7 +79,7 @@
 {
     Q_OBJECT
 public:
-    KisFloatColorInput(QWidget* parent, const KoChannelInfo*, KoColor* color, KoColorDisplayRendererInterface *displayRenderer = KoDumbColorDisplayRenderer::instance());
+    KisFloatColorInput(QWidget* parent, const KoChannelInfo*, KoColor* color, KoColorDisplayRendererInterface *displayRenderer = KoDumbColorDisplayRenderer::instance(), bool usePercentage = false);
 protected:
     QWidget* createInput() override;
 public Q_SLOTS:
@@ -86,7 +96,7 @@
 {
     Q_OBJECT
 public:
-    KisHexColorInput(QWidget* parent, KoColor* color, KoColorDisplayRendererInterface *displayRenderer = KoDumbColorDisplayRenderer::instance());
+    KisHexColorInput(QWidget* parent, KoColor* color, KoColorDisplayRendererInterface *displayRenderer = KoDumbColorDisplayRenderer::instance(), bool usePercentage = false);
 protected:
     QWidget* createInput() override;
 public Q_SLOTS:
diff --git a/libs/ui/widgets/kis_color_input.cpp b/libs/ui/widgets/kis_color_input.cpp
--- a/libs/ui/widgets/kis_color_input.cpp
+++ b/libs/ui/widgets/kis_color_input.cpp
@@ -44,7 +44,9 @@
 #include "kis_double_parse_spin_box.h"
 #include "kis_int_parse_spin_box.h"
 
-KisColorInput::KisColorInput(QWidget* parent, const KoChannelInfo* channelInfo, KoColor* color, KoColorDisplayRendererInterface *displayRenderer) : QWidget(parent), m_channelInfo(channelInfo), m_color(color), m_displayRenderer(displayRenderer)
+KisColorInput::KisColorInput(QWidget* parent, const KoChannelInfo* channelInfo, KoColor* color, KoColorDisplayRendererInterface *displayRenderer, bool usePercentage) :
+    QWidget(parent), m_channelInfo(channelInfo), m_color(color), m_displayRenderer(displayRenderer),
+    m_usePercentage(usePercentage)
 {
 }
 
@@ -66,7 +68,8 @@
     m_layout->addWidget(m_input);
 }
 
-KisIntegerColorInput::KisIntegerColorInput(QWidget* parent, const KoChannelInfo* channelInfo, KoColor* color, KoColorDisplayRendererInterface *displayRenderer) : KisColorInput(parent, channelInfo, color, displayRenderer)
+KisIntegerColorInput::KisIntegerColorInput(QWidget* parent, const KoChannelInfo* channelInfo, KoColor* color, KoColorDisplayRendererInterface *displayRenderer, bool usePercentage) :
+    KisColorInput(parent, channelInfo, color, displayRenderer, usePercentage)
 {
     init();
 }
@@ -97,29 +100,51 @@
     quint8* data = m_color->data() + m_channelInfo->pos();
     quint8* dataMin = min.data() + m_channelInfo->pos();
     quint8* dataMax = max.data() + m_channelInfo->pos();
+    m_intNumInput->blockSignals(true);
+    m_colorSlider->blockSignals(true);
     switch (m_channelInfo->channelValueType()) {
     case KoChannelInfo::UINT8:
-        m_intNumInput->setValue(*(reinterpret_cast<quint8*>(data)));
+        if (m_usePercentage) {
+            m_intNumInput->setMaximum(100);
+            m_intNumInput->setValue(round(*(reinterpret_cast<quint8*>(data))*1.0 / 255.0 * 100.0));
+        } else {
+            m_intNumInput->setMaximum(0xFF);
+            m_intNumInput->setValue(*(reinterpret_cast<quint8*>(data)));
+        }
         m_colorSlider->setValue(*(reinterpret_cast<quint8*>(data)));
         *(reinterpret_cast<quint8*>(dataMin)) = 0x0;
         *(reinterpret_cast<quint8*>(dataMax)) = 0xFF;
         break;
     case KoChannelInfo::UINT16:
-        m_intNumInput->setValue(*(reinterpret_cast<quint16*>(data)));
+        if (m_usePercentage) {
+            m_intNumInput->setMaximum(100);
+            m_intNumInput->setValue(round(*(reinterpret_cast<quint16*>(data))*1.0 / 65535.0 * 100.0));
+        } else {
+            m_intNumInput->setMaximum(0xFFFF);
+            m_intNumInput->setValue(*(reinterpret_cast<quint16*>(data)));
+        }
         m_colorSlider->setValue(*(reinterpret_cast<quint16*>(data)));
         *(reinterpret_cast<quint16*>(dataMin)) = 0x0;
         *(reinterpret_cast<quint16*>(dataMax)) = 0xFFFF;
         break;
     case KoChannelInfo::UINT32:
-        m_intNumInput->setValue(*(reinterpret_cast<quint32*>(data)));
+        if (m_usePercentage) {
+            m_intNumInput->setMaximum(100);
+            m_intNumInput->setValue(round(*(reinterpret_cast<quint32*>(data))*1.0 / 4294967295.0 * 100.0));
+        } else {
+            m_intNumInput->setMaximum(0xFFFF);
+            m_intNumInput->setValue(*(reinterpret_cast<quint32*>(data)));
+        }
         m_colorSlider->setValue(*(reinterpret_cast<quint32*>(data)));
         *(reinterpret_cast<quint32*>(dataMin)) = 0x0;
         *(reinterpret_cast<quint32*>(dataMax)) = 0xFFFFFFFF;
         break;
     default:
         Q_ASSERT(false);
     }
     m_colorSlider->setColors(min, max);
+    m_intNumInput->blockSignals(false);
+    m_colorSlider->blockSignals(false);
 }
 
 QWidget* KisIntegerColorInput::createInput()
@@ -129,27 +154,93 @@
     m_colorSlider->setMinimum(0);
     switch (m_channelInfo->channelValueType()) {
     case KoChannelInfo::UINT8:
-        m_intNumInput->setMaximum(0xFF);
+        if (m_usePercentage) {
+            m_intNumInput->setMaximum(100);
+        } else {
+            m_intNumInput->setMaximum(0xFF);
+        }
         m_colorSlider->setMaximum(0xFF);
         break;
     case KoChannelInfo::UINT16:
-        m_intNumInput->setMaximum(0xFFFF);
+        if (m_usePercentage) {
+            m_intNumInput->setMaximum(100);
+        } else {
+            m_intNumInput->setMaximum(0xFFFF);
+        }
         m_colorSlider->setMaximum(0xFFFF);
         break;
     case KoChannelInfo::UINT32:
-        m_intNumInput->setMaximum(0xFFFFFFFF);
+        if (m_usePercentage) {
+            m_intNumInput->setMaximum(100);
+        } else {
+            m_intNumInput->setMaximum(0xFFFFFFFF);
+        }
         m_colorSlider->setMaximum(0xFFFFFFFF);
         break;
     default:
         Q_ASSERT(false);
     }
-    connect(m_colorSlider, SIGNAL(valueChanged(int)), m_intNumInput, SLOT(setValue(int)));
-    connect(m_intNumInput, SIGNAL(valueChanged(int)), this, SLOT(setValue(int)));
+    connect(m_colorSlider, SIGNAL(valueChanged(int)), this, SLOT(onColorSliderChanged(int)));
+    connect(m_intNumInput, SIGNAL(valueChanged(int)), this, SLOT(onNumInputChanged(int)));
     return m_intNumInput;
 }
 
+void KisIntegerColorInput::onColorSliderChanged(int val)
+{
+    m_intNumInput->blockSignals(true);
+    if (m_usePercentage) {
+        switch (m_channelInfo->channelValueType()) {
+        case KoChannelInfo::UINT8:
+            m_intNumInput->setValue(round((val*1.0) / 255.0 * 100.0));
+            break;
+        case KoChannelInfo::UINT16:
+            m_intNumInput->setValue(round((val*1.0) / 65535.0 * 100.0));
+            break;
+        case KoChannelInfo::UINT32:
+            m_intNumInput->setValue(round((val*1.0) / 4294967295.0 * 100.0));
+            break;
+        default:
+            Q_ASSERT(false);
+        }
+    } else {
+        m_intNumInput->setValue(val);
+    }
+    m_intNumInput->blockSignals(false);
+    setValue(val);
+}
+
+void KisIntegerColorInput::onNumInputChanged(int val)
+{
+    m_colorSlider->blockSignals(true);
+    if (m_usePercentage) {
+        switch (m_channelInfo->channelValueType()) {
+        case KoChannelInfo::UINT8:
+            m_colorSlider->setValue((val*1.0)/100.0 * 255.0);
+            m_colorSlider->blockSignals(false);
+            setValue((val*1.0)/100.0 * 255.0);
+            break;
+        case KoChannelInfo::UINT16:
+            m_colorSlider->setValue((val*1.0)/100.0 * 65535.0);
+            m_colorSlider->blockSignals(false);
+            setValue((val*1.0)/100.0 * 65535.0);
+            break;
+        case KoChannelInfo::UINT32:
+            m_colorSlider->setValue((val*1.0)/100.0 * 4294967295.0);
+            m_colorSlider->blockSignals(false);
+            setValue((val*1.0)/100.0 * 4294967295.0);
+            break;
+        default:
+            Q_ASSERT(false);
+        }
+    } else {
+        m_colorSlider->setValue(val);
+        m_colorSlider->blockSignals(false);
+        setValue(val);
+    }
+}
 
-KisFloatColorInput::KisFloatColorInput(QWidget* parent, const KoChannelInfo* channelInfo, KoColor* color, KoColorDisplayRendererInterface *displayRenderer) : KisColorInput(parent, channelInfo, color, displayRenderer)
+KisFloatColorInput::KisFloatColorInput(QWidget* parent, const KoChannelInfo* channelInfo, KoColor* color, KoColorDisplayRendererInterface *displayRenderer, bool usePercentage) :
+    KisColorInput(parent, channelInfo, color, displayRenderer, usePercentage)
 {
     init();
 }
@@ -241,7 +332,8 @@
     m_colorSlider->setValue((value - m_minValue) / floatRange * 255);
 }
 
-KisHexColorInput::KisHexColorInput(QWidget* parent, KoColor* color, KoColorDisplayRendererInterface *displayRenderer) : KisColorInput(parent, 0, color, displayRenderer)
+KisHexColorInput::KisHexColorInput(QWidget* parent, KoColor* color, KoColorDisplayRendererInterface *displayRenderer, bool usePercentage) :
+    KisColorInput(parent, 0, color, displayRenderer, usePercentage)
 {
     QHBoxLayout* m_layout = new QHBoxLayout(this);
     m_layout->setContentsMargins(0,0,0,0);
diff --git a/plugins/dockers/specificcolorselector/kis_specific_color_selector_widget.h b/plugins/dockers/specificcolorselector/kis_specific_color_selector_widget.h
--- a/plugins/dockers/specificcolorselector/kis_specific_color_selector_widget.h
+++ b/plugins/dockers/specificcolorselector/kis_specific_color_selector_widget.h
@@ -49,6 +49,7 @@
     void updateTimeout();
     void setCustomColorSpace(const KoColorSpace *);
     void rereadCurrentColorSpace(bool force = false);
+    void onChkUsePercentageChanged(bool);
 Q_SIGNALS:
     void colorChanged(const KoColor&);
     void updated();
@@ -63,6 +64,7 @@
     KisColorSpaceSelector *m_colorspaceSelector;
     bool m_customColorSpaceSelected;
     QCheckBox *m_chkShowColorSpaceSelector;
+    QCheckBox *m_chkUsePercentage;
 
     KisDisplayColorConverter *m_displayConverter;
     KisSignalAutoConnectionsStore m_converterConnection;
diff --git a/plugins/dockers/specificcolorselector/kis_specific_color_selector_widget.cc b/plugins/dockers/specificcolorselector/kis_specific_color_selector_widget.cc
--- a/plugins/dockers/specificcolorselector/kis_specific_color_selector_widget.cc
+++ b/plugins/dockers/specificcolorselector/kis_specific_color_selector_widget.cc
@@ -30,6 +30,7 @@
 #include <KoChannelInfo.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
+#include <KoColorModelStandardIds.h>
 
 #include <kis_color_input.h>
 #include <KoColorProfile.h>
@@ -61,13 +62,18 @@
     m_chkShowColorSpaceSelector = new QCheckBox(i18n("Show Colorspace Selector"), this);
     connect(m_chkShowColorSpaceSelector, SIGNAL(toggled(bool)), m_colorspaceSelector, SLOT(setVisible(bool)));
 
+    m_chkUsePercentage = new QCheckBox(i18n("Use Percentage"), this);
+    connect(m_chkUsePercentage, SIGNAL(toggled(bool)), this, SLOT(onChkUsePercentageChanged(bool)));
+
     KConfigGroup cfg =  KSharedConfig::openConfig()->group(QString());
     m_chkShowColorSpaceSelector->setChecked(cfg.readEntry("SpecificColorSelector/ShowColorSpaceSelector", true));
+    m_chkUsePercentage->setChecked(cfg.readEntry("SpecificColorSelector/UsePercentage", false));
 
     m_colorspaceSelector->setVisible(m_chkShowColorSpaceSelector->isChecked());
     m_colorspaceSelector->showColorBrowserButton(false);
 
     m_layout->addWidget(m_chkShowColorSpaceSelector);
+    m_layout->addWidget(m_chkUsePercentage);
     m_layout->addWidget(m_colorspaceSelector);
 
     m_spacer = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Expanding);
@@ -78,6 +84,7 @@
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group(QString());
     cfg.writeEntry("SpecificColorSelector/ShowColorSpaceSelector", m_chkShowColorSpaceSelector->isChecked());
+    cfg.writeEntry("SpecificColorSelector/UsePercentage", m_chkUsePercentage->isChecked());
 }
 
 bool KisSpecificColorSelectorWidget::customColorSpaceUsed()
@@ -122,6 +129,12 @@
         return;
     }
 
+    if (cs->colorDepthId() == Integer8BitsColorDepthID || cs->colorDepthId() == Integer16BitsColorDepthID) {
+        m_chkUsePercentage->setVisible(true);
+    } else {
+        m_chkUsePercentage->setVisible(false);
+    }
+
     m_colorSpace = KoColorSpaceRegistry::instance()->colorSpace(cs->colorModelId().id(), cs->colorDepthId().id(), cs->profile());
     Q_ASSERT(m_colorSpace);
     Q_ASSERT(*m_colorSpace == *cs);
@@ -147,7 +160,7 @@
             case KoChannelInfo::UINT8:
             case KoChannelInfo::UINT16:
             case KoChannelInfo::UINT32: {
-                input = new KisIntegerColorInput(this, channel, &m_color, displayRenderer);
+                input = new KisIntegerColorInput(this, channel, &m_color, displayRenderer, m_chkUsePercentage->isChecked());
             }
             break;
             case KoChannelInfo::FLOAT16:
@@ -233,4 +246,11 @@
     setColor(m_color);
 }
 
+void KisSpecificColorSelectorWidget::onChkUsePercentageChanged(bool isChecked)
+{
+    for (auto input: m_inputs) {
+        input->setPercentageWise(isChecked);
+    }
+    emit(updated());
+}
 #include "moc_kis_specific_color_selector_widget.cpp"