{"id":10110,"date":"2026-08-31T11:16:30","date_gmt":"2026-08-31T11:16:30","guid":{"rendered":"https:\/\/inskill.in\/training\/?p=10110"},"modified":"2026-08-25T11:21:14","modified_gmt":"2026-08-25T11:21:14","slug":"signed-vs-unsigned-data-types-systemverilog-rtl","status":"publish","type":"post","link":"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/","title":{"rendered":"Signed vs Unsigned Data Types in SystemVerilog RTL"},"content":{"rendered":"\t\t<div data-elementor-type=\"wp-post\" data-elementor-id=\"10110\" class=\"elementor elementor-10110\">\n\t\t\t\t\t\t\t\t\t<section class=\"elementor-section elementor-top-section elementor-element elementor-element-c00b5ff elementor-section-boxed elementor-section-height-default elementor-section-height-default wpr-particle-no wpr-jarallax-no wpr-parallax-no wpr-sticky-section-no\" data-id=\"c00b5ff\" data-element_type=\"section\">\n\t\t\t\t\t\t<div class=\"elementor-container elementor-column-gap-default\">\n\t\t\t\t\t<div class=\"elementor-column elementor-col-100 elementor-top-column elementor-element elementor-element-fa0953d\" data-id=\"fa0953d\" data-element_type=\"column\">\n\t\t\t<div class=\"elementor-widget-wrap elementor-element-populated\">\n\t\t\t\t\t\t\t\t<div class=\"elementor-element elementor-element-184ffac elementor-widget elementor-widget-text-editor\" data-id=\"184ffac\" data-element_type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t<style>\/*! elementor - v3.11.2 - 22-02-2023 *\/\n.elementor-widget-text-editor.elementor-drop-cap-view-stacked .elementor-drop-cap{background-color:#818a91;color:#fff}.elementor-widget-text-editor.elementor-drop-cap-view-framed .elementor-drop-cap{color:#818a91;border:3px solid;background-color:transparent}.elementor-widget-text-editor:not(.elementor-drop-cap-view-default) .elementor-drop-cap{margin-top:8px}.elementor-widget-text-editor:not(.elementor-drop-cap-view-default) .elementor-drop-cap-letter{width:1em;height:1em}.elementor-widget-text-editor .elementor-drop-cap{float:left;text-align:center;line-height:1;font-size:50px}.elementor-widget-text-editor .elementor-drop-cap-letter{display:inline-block}<\/style>\t\t\t\t<p><span style=\"font-weight: 400;\">A SystemVerilog signal can contain exactly the same bits and still produce a completely different result depending on whether it is treated as <\/span><b>signed or unsigned<\/b><span style=\"font-weight: 400;\">.<\/span><\/p><p><span style=\"font-weight: 400;\">That is one of the easiest RTL concepts to underestimate.<\/span><\/p><p><span style=\"font-weight: 400;\">For example, an 8-bit vector containing:<\/span><\/p><p><span style=\"font-weight: 400;\">8&#8217;b1111_1111<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">can represent <\/span><b>255<\/b><span style=\"font-weight: 400;\"> when interpreted as unsigned or <\/span><b>-1<\/b><span style=\"font-weight: 400;\"> when interpreted as signed two&#8217;s complement.<\/span><\/p><p><span style=\"font-weight: 400;\">The bits have not changed. What changes is how SystemVerilog interprets those bits during operations such as arithmetic, comparison, extension, and assignment.<\/span><\/p><p><span style=\"font-weight: 400;\">This distinction becomes especially important when designing datapaths, ALUs, counters, address calculations, DSP blocks, control logic, and arithmetic-heavy RTL. A design may compile, simulate, and synthesize successfully while still producing incorrect results because signed and unsigned values were unintentionally mixed.<\/span><\/p><p><span style=\"font-weight: 400;\">Understanding signedness is therefore not just a language-detail exercise. It is an essential RTL design skill.<\/span><\/p><p>\u00a0<\/p><h3><span style=\"font-weight: 400;\">What Does Signed and Unsigned Mean?<\/span><\/h3><p><span style=\"font-weight: 400;\">In SystemVerilog, an integral value can be interpreted as either signed or unsigned.<\/span><\/p><p><span style=\"font-weight: 400;\">An unsigned 8-bit vector:<\/span><\/p><p><span style=\"font-weight: 400;\">logic [7:0] data;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">represents values from:<\/span><\/p><p><span style=\"font-weight: 400;\">0 to 255<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">A signed 8-bit vector:<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [7:0] data;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">uses two&#8217;s complement representation and represents:<\/span><\/p><p><span style=\"font-weight: 400;\">-128 to +127<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">The same bit pattern can therefore have different numerical meanings.<\/span><\/p><p><span style=\"font-weight: 400;\">For example:<\/span><\/p><p><span style=\"font-weight: 400;\">1111_1111<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">means:<\/span><\/p><p><span style=\"font-weight: 400;\">Unsigned \u2192 255<\/span><\/p><p><span style=\"font-weight: 400;\">Signed \u00a0 \u2192 -1<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">SystemVerilog defines the default signedness of several built-in integer types. <\/span><span style=\"font-weight: 400;\">byte<\/span><span style=\"font-weight: 400;\">, <\/span><span style=\"font-weight: 400;\">shortint<\/span><span style=\"font-weight: 400;\">, <\/span><span style=\"font-weight: 400;\">int<\/span><span style=\"font-weight: 400;\">, <\/span><span style=\"font-weight: 400;\">integer<\/span><span style=\"font-weight: 400;\">, and <\/span><span style=\"font-weight: 400;\">longint<\/span><span style=\"font-weight: 400;\"> are signed by default, while <\/span><span style=\"font-weight: 400;\">bit<\/span><span style=\"font-weight: 400;\">, <\/span><span style=\"font-weight: 400;\">logic<\/span><span style=\"font-weight: 400;\">, <\/span><span style=\"font-weight: 400;\">reg<\/span><span style=\"font-weight: 400;\">, and <\/span><span style=\"font-weight: 400;\">time<\/span><span style=\"font-weight: 400;\"> are unsigned by default. Packed arrays of those unsigned element types are also unsigned unless explicitly declared otherwise.<\/span><\/p><p><span style=\"font-weight: 400;\">That is why explicitly declaring the intended signedness is often a good RTL coding practice.<\/span><\/p><p>\u00a0<\/p><h3><span style=\"font-weight: 400;\">Declaring Signed and Unsigned Signals<\/span><\/h3><p><span style=\"font-weight: 400;\">The syntax is straightforward.<\/span><\/p><h5><span style=\"font-weight: 400;\">Unsigned vector<\/span><\/h5><p><span style=\"font-weight: 400;\">logic [15:0] data;<\/span><\/p><p>\u00a0<\/p><h5><span style=\"font-weight: 400;\">Signed vector<\/span><\/h5><p><span style=\"font-weight: 400;\">logic signed [15:0] data;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">You can also explicitly specify unsigned:<\/span><\/p><p><span style=\"font-weight: 400;\">logic unsigned [15:0] data;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">For predefined integer types:<\/span><\/p><p><span style=\"font-weight: 400;\">int signed temperature;<\/span><\/p><p><span style=\"font-weight: 400;\">int unsigned count;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">Explicit declarations make the design intent easier to understand during code reviews.<\/span><\/p><p><span style=\"font-weight: 400;\">For example:<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [15:0] sample;<\/span><\/p><p><span style=\"font-weight: 400;\">logic\u00a0 \u00a0 \u00a0 \u00a0 [15:0] address;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">immediately tells another engineer that <\/span><span style=\"font-weight: 400;\">sample<\/span><span style=\"font-weight: 400;\"> represents a signed quantity while <\/span><span style=\"font-weight: 400;\">address<\/span><span style=\"font-weight: 400;\"> is treated as an unsigned bit vector.<\/span><\/p><p>\u00a0<\/p><h3><span style=\"font-weight: 400;\">Why Signedness Matters in RTL<\/span><\/h3><p><span style=\"font-weight: 400;\">The problem usually does not appear when simply storing or moving bits.<\/span><\/p><p><span style=\"font-weight: 400;\">It appears when those bits participate in an expression.<\/span><\/p><p><span style=\"font-weight: 400;\">Consider:<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [7:0] a;<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [7:0] b;<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [8:0] result;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">assign result = a + b;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">Here, both operands are signed, so signed arithmetic is intended.<\/span><\/p><p><span style=\"font-weight: 400;\">Now imagine:<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [7:0] a;<\/span><\/p><p><span style=\"font-weight: 400;\">logic\u00a0 \u00a0 \u00a0 \u00a0 [7:0] b;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">assign result = a + b;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">Now the expression contains a signed operand and an unsigned operand.<\/span><\/p><p><span style=\"font-weight: 400;\">This is where SystemVerilog&#8217;s expression rules become important. Automatic conversions can produce results that are different from what a designer intuitively expects. Mixing signed and unsigned arithmetic is therefore a common source of subtle RTL bugs.<\/span><\/p><p><span style=\"font-weight: 400;\">A useful engineering habit is:<\/span><\/p><p><b>Do not mix signed and unsigned operands casually. Make the intended interpretation explicit.<\/b><\/p><p>\u00a0<\/p><h3><span style=\"font-weight: 400;\">Signedness Affects Comparisons<\/span><\/h3><p><span style=\"font-weight: 400;\">One of the most dangerous examples is relational comparison.<\/span><\/p><p><span style=\"font-weight: 400;\">Suppose:<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [7:0] a;<\/span><\/p><p><span style=\"font-weight: 400;\">logic\u00a0 \u00a0 \u00a0 \u00a0 [7:0] b;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">assign result = (a &lt; b);<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">If <\/span><span style=\"font-weight: 400;\">a<\/span><span style=\"font-weight: 400;\"> contains:<\/span><\/p><p><span style=\"font-weight: 400;\">1111_1111<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">a designer thinking in signed arithmetic may interpret it as:<\/span><\/p><p><span style=\"font-weight: 400;\">a = -1<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">But <\/span><span style=\"font-weight: 400;\">b<\/span><span style=\"font-weight: 400;\"> and the expression&#8217;s signedness rules can cause the comparison to be evaluated differently than expected.<\/span><\/p><p><span style=\"font-weight: 400;\">For unsigned interpretation:<\/span><\/p><p><span style=\"font-weight: 400;\">1111_1111 = 255<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">For signed interpretation:<\/span><\/p><p><span style=\"font-weight: 400;\">1111_1111 = -1<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">So the same physical bits can lead to completely different comparison results.<\/span><\/p><p><span style=\"font-weight: 400;\">This matters in:<\/span><\/p><ul><li style=\"font-weight: 400;\" aria-level=\"1\"><span style=\"font-weight: 400;\">range checking<\/span><\/li><li style=\"font-weight: 400;\" aria-level=\"1\"><span style=\"font-weight: 400;\">overflow detection<\/span><\/li><li style=\"font-weight: 400;\" aria-level=\"1\"><span style=\"font-weight: 400;\">threshold logic<\/span><\/li><li style=\"font-weight: 400;\" aria-level=\"1\"><span style=\"font-weight: 400;\">counters<\/span><\/li><li style=\"font-weight: 400;\" aria-level=\"1\"><span style=\"font-weight: 400;\">address comparisons<\/span><\/li><li style=\"font-weight: 400;\" aria-level=\"1\"><span style=\"font-weight: 400;\">packet length checks<\/span><\/li><li style=\"font-weight: 400;\" aria-level=\"1\"><span style=\"font-weight: 400;\">signed DSP calculations<\/span><\/li><\/ul><p><span style=\"font-weight: 400;\">When a comparison crosses a signed\/unsigned boundary, make the conversion explicit instead of relying on implicit rules.<\/span><\/p><p>\u00a0<\/p><h3><span style=\"font-weight: 400;\">Sign Extension vs Zero Extension<\/span><\/h3><p><span style=\"font-weight: 400;\">Another major difference appears when a value is widened.<\/span><\/p><p><span style=\"font-weight: 400;\">Suppose an 8-bit signed number is:<\/span><\/p><p><span style=\"font-weight: 400;\">1111_1110<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">As a signed value, this is:<\/span><\/p><p><span style=\"font-weight: 400;\">-2<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">When extending it to 16 bits, the sign bit must be replicated:<\/span><\/p><p><span style=\"font-weight: 400;\">1111_1111_1111_1110<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">This is called sign extension.<\/span><\/p><p><span style=\"font-weight: 400;\">For an unsigned value, zero extension is used:<\/span><\/p><p><span style=\"font-weight: 400;\">0000_0000_1111_1110<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">So:<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [7:0]\u00a0 signed_data;<\/span><\/p><p><span style=\"font-weight: 400;\">logic\u00a0 \u00a0 \u00a0 \u00a0 [7:0]\u00a0 unsigned_data;<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [15:0] extended_data;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">The interpretation of the source determines how the value is extended.<\/span><\/p><p><span style=\"font-weight: 400;\">This is one reason why signedness must be established before arithmetic operations occur.<\/span><\/p><p>\u00a0<\/p><h3><span style=\"font-weight: 400;\">A Common Literal Mistake<\/span><\/h3><p><span style=\"font-weight: 400;\">Numeric literals are another place where RTL engineers can accidentally introduce signedness problems.<\/span><\/p><p><span style=\"font-weight: 400;\">For example:<\/span><\/p><p><span style=\"font-weight: 400;\">8&#8217;d255<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">is an 8-bit decimal literal.<\/span><\/p><p><span style=\"font-weight: 400;\">If a signed representation is required, SystemVerilog allows the signed modifier:<\/span><\/p><p><span style=\"font-weight: 400;\">8&#8217;sd255<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">However, assigning a value outside the representable range to a signed 8-bit quantity does not magically expand its range.<\/span><\/p><p><span style=\"font-weight: 400;\">For example:<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [7:0] value;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">assign value = 8&#8217;d255;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">The eight bits are:<\/span><\/p><p><span style=\"font-weight: 400;\">1111_1111<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">When stored in the signed 8-bit destination, those bits represent <\/span><span style=\"font-weight: 400;\">-1<\/span><span style=\"font-weight: 400;\">.<\/span><\/p><p><span style=\"font-weight: 400;\">This is an important distinction:<\/span><\/p><p><b>Bit width determines how many bits are available; signedness determines how those bits are interpreted.<\/b><\/p><p>\u00a0<\/p><h3><span style=\"font-weight: 400;\">Part-Selects Can Change the Situation<\/span><\/h3><p><span style=\"font-weight: 400;\">A particularly easy mistake is assuming that selecting part of a signed vector automatically preserves its signed nature.<\/span><\/p><p><span style=\"font-weight: 400;\">Consider:<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [15:0] data;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">logic [7:0] lower;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">assign lower = data[7:0];<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">The selected portion is treated as an unsigned value. The SystemVerilog standard specifies that a part-select of a packed array is unsigned.<\/span><\/p><p><span style=\"font-weight: 400;\">This can matter when a selected field is subsequently used in arithmetic.<\/span><\/p><p><span style=\"font-weight: 400;\">For example:<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [15:0] data;<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [8:0] result;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">assign result = data[7:0] + 1;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">If the selected field is supposed to represent a signed 8-bit quantity, it is better to make that intention explicit.<\/span><\/p><p><span style=\"font-weight: 400;\">One option is:<\/span><\/p><p><span style=\"font-weight: 400;\">assign result = $signed(data[7:0]) + 1;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">or use an explicit cast.<\/span><\/p><p><span style=\"font-weight: 400;\">The key lesson is that <\/span><b>selecting bits is not always equivalent to extracting a signed number<\/b><span style=\"font-weight: 400;\">.<\/span><\/p><p>\u00a0<\/p><h3><span style=\"font-weight: 400;\">Use $signed and $unsigned Carefully<\/span><\/h3><p><span style=\"font-weight: 400;\">SystemVerilog provides system functions for explicitly changing the signedness of an expression:<\/span><\/p><p><span style=\"font-weight: 400;\">$signed(expression)<\/span><\/p><p><span style=\"font-weight: 400;\">$unsigned(expression)<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">For example:<\/span><\/p><p><span style=\"font-weight: 400;\">logic [7:0] data;<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [8:0] result;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">assign result = $signed(data);<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">However, simply changing the interpretation is not necessarily the same as mathematically converting an unsigned number into a larger signed number.<\/span><\/p><p><span style=\"font-weight: 400;\">Suppose:<\/span><\/p><p><span style=\"font-weight: 400;\">data = 8&#8217;b1000_0000<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">As unsigned:<\/span><\/p><p><span style=\"font-weight: 400;\">128<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">If it is merely reinterpreted as signed 8-bit data, it becomes:<\/span><\/p><p><span style=\"font-weight: 400;\">-128<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">That may be exactly what you want\u2014or completely wrong.<\/span><\/p><p><span style=\"font-weight: 400;\">When widening is also required, pay attention to the width and extension behavior rather than assuming <\/span><span style=\"font-weight: 400;\">$signed()<\/span><span style=\"font-weight: 400;\"> alone solves the problem.<\/span><\/p><p><span style=\"font-weight: 400;\">SystemVerilog also supports type casting such as:<\/span><\/p><p><span style=\"font-weight: 400;\">signed'(expression)<\/span><\/p><p><span style=\"font-weight: 400;\">unsigned'(expression)<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">The language standard specifies that casting can change signedness and\/or size, with the resulting interpretation determined by the cast type.<\/span><\/p><p>\u00a0<\/p><h3><span style=\"font-weight: 400;\">Signed Arithmetic in an ALU<\/span><\/h3><p><span style=\"font-weight: 400;\">Consider a simple arithmetic unit:<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [15:0] a;<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [15:0] b;<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [15:0] result;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">always_comb begin<\/span><\/p><p><span style=\"font-weight: 400;\">\u00a0\u00a0\u00a0\u00a0case (op)<\/span><\/p><p><span style=\"font-weight: 400;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0ADD: result = a + b;<\/span><\/p><p><span style=\"font-weight: 400;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0SUB: result = a &#8211; b;<\/span><\/p><p><span style=\"font-weight: 400;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0default: result = &#8216;0;<\/span><\/p><p><span style=\"font-weight: 400;\">\u00a0\u00a0\u00a0\u00a0endcase<\/span><\/p><p><span style=\"font-weight: 400;\">end<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">Here, all operands involved in the arithmetic datapath have a clearly defined signed interpretation.<\/span><\/p><p><span style=\"font-weight: 400;\">That is much safer than something like:<\/span><\/p><p><span style=\"font-weight: 400;\">logic [15:0] a;<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [15:0] b;<\/span><\/p><p><span style=\"font-weight: 400;\">logic [15:0] result;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">and then assuming subtraction will automatically behave as signed arithmetic.<\/span><\/p><p><span style=\"font-weight: 400;\">For arithmetic datapaths, define a consistent numeric representation at the interface of the block and maintain it through intermediate signals.<\/span><\/p><p>\u00a0<\/p><h3><span style=\"font-weight: 400;\">Unsigned Data Is Usually Natural for Addresses and Bit Fields<\/span><\/h3><p><span style=\"font-weight: 400;\">Not every number should be signed.<\/span><\/p><p><span style=\"font-weight: 400;\">Addresses are generally naturally represented as unsigned quantities:<\/span><\/p><p><span style=\"font-weight: 400;\">logic [31:0] address;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">Likewise, many fields represent:<\/span><\/p><ul><li style=\"font-weight: 400;\" aria-level=\"1\"><span style=\"font-weight: 400;\">instruction encodings<\/span><\/li><li style=\"font-weight: 400;\" aria-level=\"1\"><span style=\"font-weight: 400;\">register indexes<\/span><\/li><li style=\"font-weight: 400;\" aria-level=\"1\"><span style=\"font-weight: 400;\">packet lengths<\/span><\/li><li style=\"font-weight: 400;\" aria-level=\"1\"><span style=\"font-weight: 400;\">bit masks<\/span><\/li><li style=\"font-weight: 400;\" aria-level=\"1\"><span style=\"font-weight: 400;\">memory addresses<\/span><\/li><li style=\"font-weight: 400;\" aria-level=\"1\"><span style=\"font-weight: 400;\">control fields<\/span><\/li><li style=\"font-weight: 400;\" aria-level=\"1\"><span style=\"font-weight: 400;\">identifiers<\/span><\/li><\/ul><p><span style=\"font-weight: 400;\">These are not normally negative quantities.<\/span><\/p><p><span style=\"font-weight: 400;\">Using signed types unnecessarily can create confusing comparisons and extensions.<\/span><\/p><p><span style=\"font-weight: 400;\">A good RTL designer therefore does not simply choose <\/span><span style=\"font-weight: 400;\">signed<\/span><span style=\"font-weight: 400;\"> everywhere.<\/span><\/p><p><span style=\"font-weight: 400;\">Instead, ask:<\/span><\/p><p><b>&#8220;Does this signal represent a mathematical quantity that can be negative, or is it fundamentally a bit pattern\/non-negative quantity?&#8221;<\/b><\/p><p><span style=\"font-weight: 400;\">That question usually leads to the correct declaration.<\/span><\/p><p>\u00a0<\/p><h3><span style=\"font-weight: 400;\">The Danger of Unsized Constants<\/span><\/h3><p><span style=\"font-weight: 400;\">Unsized numeric constants can also make expression behavior harder to reason about.<\/span><\/p><p><span style=\"font-weight: 400;\">For example:<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [7:0] a;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">assign result = a + 1;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">The literal <\/span><span style=\"font-weight: 400;\">1<\/span><span style=\"font-weight: 400;\"> is not simply a one-bit value. Unsized integer literals have language-defined sizing and signedness behavior, which can affect expression evaluation.<\/span><\/p><p><span style=\"font-weight: 400;\">For ordinary small constants such as:<\/span><\/p><p><span style=\"font-weight: 400;\">0<\/span><\/p><p><span style=\"font-weight: 400;\">1<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">the behavior is often convenient.<\/span><\/p><p><span style=\"font-weight: 400;\">But in width-sensitive arithmetic, explicit sizing can make intent clearer:<\/span><\/p><p><span style=\"font-weight: 400;\">assign result = a + 8&#8217;sd1;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">or define appropriately sized constants using parameters or localparams.<\/span><\/p><p><span style=\"font-weight: 400;\">The goal is not to make every line unnecessarily verbose. It is to eliminate ambiguity where width and signedness affect functionality.<\/span><\/p><p>\u00a0<\/p><h3><span style=\"font-weight: 400;\">A Practical Example: Signed Sensor Data<\/span><\/h3><p><span style=\"font-weight: 400;\">Imagine a sensor interface produces a 12-bit two&#8217;s-complement measurement.<\/span><\/p><p><span style=\"font-weight: 400;\">A suitable declaration might be:<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [11:0] sensor_data;<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [15:0] calibrated_data;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">A calibration offset can then be represented consistently:<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [15:0] offset;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">assign calibrated_data = sensor_data + offset;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">If <\/span><span style=\"font-weight: 400;\">sensor_data<\/span><span style=\"font-weight: 400;\"> were accidentally declared unsigned:<\/span><\/p><p><span style=\"font-weight: 400;\">logic [11:0] sensor_data;<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">negative sensor measurements could be interpreted as large positive numbers.<\/span><\/p><p><span style=\"font-weight: 400;\">For example, a 12-bit two&#8217;s-complement representation of <\/span><span style=\"font-weight: 400;\">-1<\/span><span style=\"font-weight: 400;\"> is:<\/span><\/p><p><span style=\"font-weight: 400;\">1111_1111_1111<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">As signed:<\/span><\/p><p><span style=\"font-weight: 400;\">-1<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">As unsigned:<\/span><\/p><p><span style=\"font-weight: 400;\">4095<\/span><\/p><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">That is not a small numerical difference. It can completely break downstream control or filtering logic.<\/span><\/p><p>\u00a0<\/p><h3><span style=\"font-weight: 400;\">Best Practices for Signed and Unsigned RTL<\/span><\/h3><p>\u00a0<\/p><p><span style=\"font-weight: 400;\">A few habits make signedness bugs much easier to prevent.<\/span><\/p><p>\u00a0<\/p><h5><span style=\"font-weight: 400;\">1. Declare intent explicitly<\/span><\/h5><p><span style=\"font-weight: 400;\">Use:<\/span><\/p><p><span style=\"font-weight: 400;\">logic signed [N-1:0]<\/span><\/p><p><span style=\"font-weight: 400;\">when a vector represents a signed number.<\/span><\/p><h5><span style=\"font-weight: 400;\">2. Avoid unnecessary mixing<\/span><\/h5><p><span style=\"font-weight: 400;\">Keep operands consistently signed or unsigned within an arithmetic datapath.<\/span><\/p><h5><span style=\"font-weight: 400;\">3. Be careful with part-selects<\/span><\/h5><p><span style=\"font-weight: 400;\">Remember that a part-select can be treated as unsigned. Apply an explicit cast when a signed interpretation is required.<\/span><\/p><h5><span style=\"font-weight: 400;\">4. Review expression width<\/span><\/h5><p><span style=\"font-weight: 400;\">Signedness and width are closely related. A correct signed declaration does not automatically guarantee the desired result width.<\/span><\/p><h5><span style=\"font-weight: 400;\">5. Use explicit casting when intent matters<\/span><\/h5><p><span style=\"font-weight: 400;\">For example:<\/span><\/p><p><span style=\"font-weight: 400;\">$signed(signal)<\/span><\/p><p><span style=\"font-weight: 400;\">or:<\/span><\/p><p><span style=\"font-weight: 400;\">signed'(signal)<\/span><\/p><p><span style=\"font-weight: 400;\">can make the intended interpretation obvious.<\/span><\/p><h5><span style=\"font-weight: 400;\">6. Check lint warnings<\/span><\/h5><p><span style=\"font-weight: 400;\">Good RTL linting can identify suspicious signed\/unsigned conversions and width mismatches before they become silicon problems.<\/span><\/p><h5><span style=\"font-weight: 400;\">7. Test boundary values<\/span><\/h5><p><span style=\"font-weight: 400;\">Do not test only normal positive numbers.<\/span><\/p><p><span style=\"font-weight: 400;\">For signed datapaths, include:<\/span><\/p><p><span style=\"font-weight: 400;\">0<\/span><\/p><p><span style=\"font-weight: 400;\">1<\/span><\/p><p><span style=\"font-weight: 400;\">-1<\/span><\/p><p><span style=\"font-weight: 400;\">maximum positive value<\/span><\/p><p><span style=\"font-weight: 400;\">minimum negative value<\/span><\/p><p><span style=\"font-weight: 400;\">Also test values around overflow boundaries.<\/span><\/p><p>\u00a0<\/p><h4><span style=\"font-weight: 400;\">Final Thoughts<\/span><\/h4><p><span style=\"font-weight: 400;\">Signed and unsigned data types in SystemVerilog are easy to understand at the declaration level but become much more subtle when expressions are involved.<\/span><\/p><p><span style=\"font-weight: 400;\">The important point is that <\/span><b>signedness is part of the meaning of a value, not merely a label attached to a signal<\/b><span style=\"font-weight: 400;\">.<\/span><\/p><p><span style=\"font-weight: 400;\">Two 8-bit vectors can contain identical bits and still represent completely different numbers. That difference affects arithmetic, comparison, extension, literals, part-selects, and casting.<\/span><\/p><p><span style=\"font-weight: 400;\">For RTL engineers, the safest approach is straightforward: define the numeric intent of each signal, keep arithmetic operands consistent, understand how widths change during expressions, and use explicit casts whenever the intended interpretation could be ambiguous.<\/span><\/p><p><span style=\"font-weight: 400;\">A few extra characters such as:<\/span><\/p><p><span style=\"font-weight: 400;\">signed<\/span><\/p><p><span style=\"font-weight: 400;\">unsigned<\/span><\/p><p><span style=\"font-weight: 400;\">$signed()<\/span><\/p><p><span style=\"font-weight: 400;\">$unsigned()<\/span><\/p><p><span style=\"font-weight: 400;\">can prevent hours of debugging later.<\/span><\/p><p><span style=\"font-weight: 400;\">When signedness is treated as part of the architecture rather than as a syntax detail, SystemVerilog RTL becomes much easier to reason about, and the resulting hardware is far more likely to behave exactly as intended.<\/span><\/p>\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t\t\t\t<\/div>\n\t\t","protected":false},"excerpt":{"rendered":"<p>A SystemVerilog signal can contain exactly the same bits and still produce a completely different result depending on whether it is treated as signed or unsigned. That is one of the easiest RTL concepts to underestimate. For example, an 8-bit vector containing: 8&#8217;b1111_1111 \u00a0 can represent 255 when interpreted as unsigned or -1 when interpreted [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[8],"tags":[],"class_list":["post-10110","post","type-post","status-publish","format-standard","hentry","category-vlsi"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v26.7 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Signed vs Unsigned Data Types in SystemVerilog RTL<\/title>\n<meta name=\"description\" content=\"Learn the difference between signed and unsigned data types in SystemVerilog RTL, including arithmetic, comparisons, sizing, casting, and common coding mistakes.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Signed vs Unsigned Data Types in SystemVerilog RTL\" \/>\n<meta property=\"og:description\" content=\"Learn the difference between signed and unsigned data types in SystemVerilog RTL, including arithmetic, comparisons, sizing, casting, and common coding mistakes.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/\" \/>\n<meta property=\"og:site_name\" content=\"Inskill VLSIGURU Elearning Platform\" \/>\n<meta property=\"article:published_time\" content=\"2026-08-31T11:16:30+00:00\" \/>\n<meta name=\"author\" content=\"admin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"admin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"8 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/\"},\"author\":{\"name\":\"admin\",\"@id\":\"https:\/\/inskill.in\/training\/#\/schema\/person\/9abb65edd31606e6675ad9c153f2d42f\"},\"headline\":\"Signed vs Unsigned Data Types in SystemVerilog RTL\",\"datePublished\":\"2026-08-31T11:16:30+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/\"},\"wordCount\":1728,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\/\/inskill.in\/training\/#organization\"},\"articleSection\":[\"VLSI\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/\",\"url\":\"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/\",\"name\":\"Signed vs Unsigned Data Types in SystemVerilog RTL\",\"isPartOf\":{\"@id\":\"https:\/\/inskill.in\/training\/#website\"},\"datePublished\":\"2026-08-31T11:16:30+00:00\",\"description\":\"Learn the difference between signed and unsigned data types in SystemVerilog RTL, including arithmetic, comparisons, sizing, casting, and common coding mistakes.\",\"breadcrumb\":{\"@id\":\"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/inskill.in\/training\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Signed vs Unsigned Data Types in SystemVerilog RTL\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/inskill.in\/training\/#website\",\"url\":\"https:\/\/inskill.in\/training\/\",\"name\":\"Inskill VLSIGURU Elearning Platform\",\"description\":\"Best VLSI Training Institute\",\"publisher\":{\"@id\":\"https:\/\/inskill.in\/training\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/inskill.in\/training\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/inskill.in\/training\/#organization\",\"name\":\"Inskill VLSIGURU Elearning Platform\",\"url\":\"https:\/\/inskill.in\/training\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/inskill.in\/training\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/inskill.in\/training\/wp-content\/uploads\/2025\/01\/inskill-2.png\",\"contentUrl\":\"https:\/\/inskill.in\/training\/wp-content\/uploads\/2025\/01\/inskill-2.png\",\"width\":207,\"height\":89,\"caption\":\"Inskill VLSIGURU Elearning Platform\"},\"image\":{\"@id\":\"https:\/\/inskill.in\/training\/#\/schema\/logo\/image\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\/\/inskill.in\/training\/#\/schema\/person\/9abb65edd31606e6675ad9c153f2d42f\",\"name\":\"admin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/inskill.in\/training\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/ae1b84b5e32e75453917297a43292af55fcc34a59a0d20dc5403287472a37c28?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/ae1b84b5e32e75453917297a43292af55fcc34a59a0d20dc5403287472a37c28?s=96&d=mm&r=g\",\"caption\":\"admin\"},\"sameAs\":[\"https:\/\/inskill.in\/training\"],\"url\":\"https:\/\/inskill.in\/training\/author\/admin\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Signed vs Unsigned Data Types in SystemVerilog RTL","description":"Learn the difference between signed and unsigned data types in SystemVerilog RTL, including arithmetic, comparisons, sizing, casting, and common coding mistakes.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/","og_locale":"en_US","og_type":"article","og_title":"Signed vs Unsigned Data Types in SystemVerilog RTL","og_description":"Learn the difference between signed and unsigned data types in SystemVerilog RTL, including arithmetic, comparisons, sizing, casting, and common coding mistakes.","og_url":"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/","og_site_name":"Inskill VLSIGURU Elearning Platform","article_published_time":"2026-08-31T11:16:30+00:00","author":"admin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"admin","Est. reading time":"8 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/#article","isPartOf":{"@id":"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/"},"author":{"name":"admin","@id":"https:\/\/inskill.in\/training\/#\/schema\/person\/9abb65edd31606e6675ad9c153f2d42f"},"headline":"Signed vs Unsigned Data Types in SystemVerilog RTL","datePublished":"2026-08-31T11:16:30+00:00","mainEntityOfPage":{"@id":"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/"},"wordCount":1728,"commentCount":0,"publisher":{"@id":"https:\/\/inskill.in\/training\/#organization"},"articleSection":["VLSI"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/","url":"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/","name":"Signed vs Unsigned Data Types in SystemVerilog RTL","isPartOf":{"@id":"https:\/\/inskill.in\/training\/#website"},"datePublished":"2026-08-31T11:16:30+00:00","description":"Learn the difference between signed and unsigned data types in SystemVerilog RTL, including arithmetic, comparisons, sizing, casting, and common coding mistakes.","breadcrumb":{"@id":"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/inskill.in\/training\/vlsi\/signed-vs-unsigned-data-types-systemverilog-rtl\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/inskill.in\/training\/"},{"@type":"ListItem","position":2,"name":"Signed vs Unsigned Data Types in SystemVerilog RTL"}]},{"@type":"WebSite","@id":"https:\/\/inskill.in\/training\/#website","url":"https:\/\/inskill.in\/training\/","name":"Inskill VLSIGURU Elearning Platform","description":"Best VLSI Training Institute","publisher":{"@id":"https:\/\/inskill.in\/training\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/inskill.in\/training\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/inskill.in\/training\/#organization","name":"Inskill VLSIGURU Elearning Platform","url":"https:\/\/inskill.in\/training\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/inskill.in\/training\/#\/schema\/logo\/image\/","url":"https:\/\/inskill.in\/training\/wp-content\/uploads\/2025\/01\/inskill-2.png","contentUrl":"https:\/\/inskill.in\/training\/wp-content\/uploads\/2025\/01\/inskill-2.png","width":207,"height":89,"caption":"Inskill VLSIGURU Elearning Platform"},"image":{"@id":"https:\/\/inskill.in\/training\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/inskill.in\/training\/#\/schema\/person\/9abb65edd31606e6675ad9c153f2d42f","name":"admin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/inskill.in\/training\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/ae1b84b5e32e75453917297a43292af55fcc34a59a0d20dc5403287472a37c28?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/ae1b84b5e32e75453917297a43292af55fcc34a59a0d20dc5403287472a37c28?s=96&d=mm&r=g","caption":"admin"},"sameAs":["https:\/\/inskill.in\/training"],"url":"https:\/\/inskill.in\/training\/author\/admin\/"}]}},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/inskill.in\/training\/wp-json\/wp\/v2\/posts\/10110","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/inskill.in\/training\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/inskill.in\/training\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/inskill.in\/training\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/inskill.in\/training\/wp-json\/wp\/v2\/comments?post=10110"}],"version-history":[{"count":7,"href":"https:\/\/inskill.in\/training\/wp-json\/wp\/v2\/posts\/10110\/revisions"}],"predecessor-version":[{"id":10121,"href":"https:\/\/inskill.in\/training\/wp-json\/wp\/v2\/posts\/10110\/revisions\/10121"}],"wp:attachment":[{"href":"https:\/\/inskill.in\/training\/wp-json\/wp\/v2\/media?parent=10110"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/inskill.in\/training\/wp-json\/wp\/v2\/categories?post=10110"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/inskill.in\/training\/wp-json\/wp\/v2\/tags?post=10110"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}