diff --git a/apps/automated/src/ui/label/label-tests.ts b/apps/automated/src/ui/label/label-tests.ts
index 508e0f7d87..c765a8c10c 100644
--- a/apps/automated/src/ui/label/label-tests.ts
+++ b/apps/automated/src/ui/label/label-tests.ts
@@ -232,6 +232,82 @@ export class LabelTest extends testModule.UITest<Label> {
 		}
 	}
 
+	public test_maxWidth_caps_label_measured_width() {
+		const label = this.testView;
+		label.horizontalAlignment = 'left';
+		label.verticalAlignment = 'top';
+		// An explicit width larger than maxWidth: the used width is min(width, maxWidth).
+		label.width = 300;
+		label.maxWidth = 100;
+
+		this.waitUntilTestElementLayoutIsValid();
+
+		TKUnit.assertAreClose(label.getMeasuredWidth(), Utils.layout.toDevicePixels(100), 1, 'maxWidth should cap the label measured width to 100.');
+	}
+
+	public test_maxHeight_caps_label_measured_height() {
+		const label = this.testView;
+		label.horizontalAlignment = 'left';
+		label.verticalAlignment = 'top';
+		label.height = 300;
+		label.maxHeight = 100;
+
+		this.waitUntilTestElementLayoutIsValid();
+
+		TKUnit.assertAreClose(label.getMeasuredHeight(), Utils.layout.toDevicePixels(100), 1, 'maxHeight should cap the label measured height to 100.');
+	}
+
+	public test_maxWidth_larger_than_content_does_not_stretch_label() {
+		// A maximum larger than the natural content width must leave the label unaffected.
+		const label = this.testView;
+		label.horizontalAlignment = 'left';
+		label.verticalAlignment = 'top';
+		label.text = 'i';
+		label.fontSize = 9;
+		label.maxWidth = 1000;
+
+		this.waitUntilTestElementLayoutIsValid();
+
+		TKUnit.assertTrue(label.getMeasuredWidth() < Utils.layout.toDevicePixels(1000), 'A large maxWidth should not stretch the label to the maximum.');
+	}
+
+	public test_maxWidth_clamps_long_text_label() {
+		// The common responsive case: a wrapped label whose natural text is wider than maxWidth.
+		const label = this.testView;
+		label.horizontalAlignment = 'left';
+		label.verticalAlignment = 'top';
+		label.textWrap = true;
+		label.text = 'This is a fairly long label text that would otherwise be much wider than one hundred dips';
+		label.maxWidth = 100;
+
+		this.waitUntilTestElementLayoutIsValid();
+
+		const eps = Utils.layout.toDevicePixels(1);
+		TKUnit.assertTrue(label.getMeasuredWidth() <= Utils.layout.toDevicePixels(100) + eps, 'maxWidth should keep a long-text label within the maximum width.');
+	}
+
+	public test_maxWidth_percent_resolves_against_parent() {
+		const label = new Label();
+		label.text = 'Label';
+		label.horizontalAlignment = 'left';
+		label.verticalAlignment = 'top';
+		// Explicit width wider than the resolved 50% cap so the clamp is deterministic.
+		label.width = 300;
+		label.maxWidth = { value: 0.5, unit: '%' };
+
+		const host = new StackLayout();
+		host.width = 200;
+		host.height = 200;
+		host.addChild(label);
+
+		const mainPage = helper.getCurrentPage();
+		mainPage.content = host;
+		TKUnit.waitUntilReady(() => host.isLoaded && host.isLayoutValid);
+
+		// 50% of the 200-dip parent = 100 dip.
+		TKUnit.assertAreClose(label.getMeasuredWidth(), Utils.layout.toDevicePixels(100), 2, 'maxWidth percent should resolve to 50% of the parent width (100).');
+	}
+
 	public test_Set_TextWrap_Native() {
 		const testLabel = this.testView;
 		testLabel.text = 'this is very very very very very very very very very very very very very very very very very very very very very very very long text';
diff --git a/apps/automated/src/ui/layouts/flexbox-layout-tests.ts b/apps/automated/src/ui/layouts/flexbox-layout-tests.ts
index 5233cfd147..d4465ec504 100644
--- a/apps/automated/src/ui/layouts/flexbox-layout-tests.ts
+++ b/apps/automated/src/ui/layouts/flexbox-layout-tests.ts
@@ -1526,11 +1526,57 @@ export const testMinHeight_works_as_lower_bound_shrink_to = test(activity_minhei
 	closeEnough(height(flexbox), height(text1) + height(text2) + height(text3) + height(text4));
 });
 
-// We do not support maxWidth/maxHeight
-// omit: testMaxWidth_initial_width_more_than_maxWidth
-// omit: testMaxWidth_works_as_upper_bound_expand_to
-// omit: testMaxHeight_initial_height_more_than_maxHeight
-// omit: testMaxHeight_works_as_lower_bound_expand_to
+let activity_maxwidth_test = () =>
+	getViews(
+		`<FlexboxLayout iosOverflowSafeArea="false" id="flexbox" width="400" height="400" backgroundColor="gray">
+            <Label id="text1" horizontalAlignment="left" verticalAlignment="top" width="200" text="1" maxWidth="100" backgroundColor="red" />
+            <Label id="text2" horizontalAlignment="left" verticalAlignment="top" width="200" text="2" maxWidth="100" backgroundColor="green" flexGrow="1" />
+        </FlexboxLayout>`,
+	);
+
+export const testMaxWidth_initial_width_more_than_maxWidth = test(activity_maxwidth_test, noop, ({ root, flexbox, text1, text2 }) => {
+	closeEnough(width(text1), dipToDp(100));
+	closeEnough(width(text2), dipToDp(100));
+});
+
+let activity_maxwidth_upper_bound_test = () =>
+	getViews(
+		`<FlexboxLayout iosOverflowSafeArea="false" id="flexbox" width="400" height="400" flexWrap="${FlexWrap.NOWRAP}" backgroundColor="gray">
+        <Label id="text1" width="50" verticalAlignment="top" text="1" maxWidth="100" flexGrow="1" backgroundColor="red" />
+        <Label id="text2" width="50" verticalAlignment="top" text="2" flexGrow="1" backgroundColor="green" />
+    </FlexboxLayout>`,
+	);
+
+export const testMaxWidth_works_as_upper_bound_expand_to = test(activity_maxwidth_upper_bound_test, noop, ({ root, flexbox, text1, text2 }) => {
+	closeEnough(width(text1), dipToDp(100));
+	closeEnough(width(text2), width(flexbox) - dipToDp(100));
+});
+
+let activity_maxheight_test = () =>
+	getViews(
+		`<FlexboxLayout iosOverflowSafeArea="false" id="flexbox" width="400" height="400" flexDirection="${FlexDirection.COLUMN}" backgroundColor="gray">
+        <Label id="text1" horizontalAlignment="left" verticalAlignment="top" height="200" text="1" maxHeight="100" backgroundColor="red" />
+        <Label id="text2" horizontalAlignment="left" verticalAlignment="top" height="200" text="2" maxHeight="100" flexGrow="1" backgroundColor="green" />
+    </FlexboxLayout>`,
+	);
+
+export const testMaxHeight_initial_height_more_than_maxHeight = test(activity_maxheight_test, noop, ({ root, flexbox, text1, text2 }) => {
+	closeEnough(height(text1), dipToDp(100));
+	closeEnough(height(text2), dipToDp(100));
+});
+
+let activity_maxheight_upper_bound_test = () =>
+	getViews(
+		`<FlexboxLayout iosOverflowSafeArea="false" id="flexbox" width="400" height="400" flexDirection="${FlexDirection.COLUMN}" flexWrap="${FlexWrap.NOWRAP}" backgroundColor="gray">
+        <Label id="text1" horizontalAlignment="left" height="50" text="1" maxHeight="100" flexGrow="1" backgroundColor="red" />
+        <Label id="text2" horizontalAlignment="left" height="50" text="2" flexGrow="1" backgroundColor="green" />
+    </FlexboxLayout>`,
+	);
+
+export const testMaxHeight_works_as_upper_bound_expand_to = test(activity_maxheight_upper_bound_test, noop, ({ root, flexbox, text1, text2 }) => {
+	closeEnough(height(text1), dipToDp(100));
+	closeEnough(height(text2), height(flexbox) - dipToDp(100));
+});
 
 let activity_views_visibility_gone = () =>
 	getViews(
diff --git a/apps/automated/src/ui/layouts/stack-layout-tests.ts b/apps/automated/src/ui/layouts/stack-layout-tests.ts
index 756b18115f..b3f0485242 100644
--- a/apps/automated/src/ui/layouts/stack-layout-tests.ts
+++ b/apps/automated/src/ui/layouts/stack-layout-tests.ts
@@ -98,6 +98,35 @@ export class StackLayoutTest extends testModule.UITest<StackLayout> {
 		TKUnit.assertEqual(this.rootLayout.getMeasuredHeight(), Math.max(this.btn1.getMeasuredHeight(), this.btn2.getMeasuredHeight()), 'Layout getMeasuredHeight should be Max of children getMeasuredHeight');
 	}
 
+	public test_maxWidth_caps_child_measured_width() {
+		this.btn1.width = 300;
+		this.btn1.maxWidth = 100;
+
+		this.waitUntilTestElementLayoutIsValid();
+
+		TKUnit.assertAreClose(this.btn1.getMeasuredWidth(), utils.layout.toDevicePixels(100), 1, 'maxWidth should cap the child measured width to 100.');
+	}
+
+	public test_maxHeight_caps_child_measured_height() {
+		this.btn1.height = 300;
+		this.btn1.maxHeight = 100;
+
+		this.waitUntilTestElementLayoutIsValid();
+
+		TKUnit.assertAreClose(this.btn1.getMeasuredHeight(), utils.layout.toDevicePixels(100), 1, 'maxHeight should cap the child measured height to 100.');
+	}
+
+	public test_maxWidth_percent_resolves_against_parent() {
+		this.rootLayout.width = 200;
+		this.btn1.width = 300;
+		this.btn1.maxWidth = { value: 0.5, unit: '%' };
+
+		this.waitUntilTestElementLayoutIsValid();
+
+		// 50% of the 200-dip parent = 100 dip.
+		TKUnit.assertAreClose(this.btn1.getMeasuredWidth(), utils.layout.toDevicePixels(100), 2, 'maxWidth percent should resolve to 50% of the parent width (100).');
+	}
+
 	public test_Padding_Vertical() {
 		this.rootLayout.width = { value: 300, unit: 'px' };
 		this.rootLayout.height = { value: 300, unit: 'px' };
diff --git a/apps/automated/src/ui/styling/style-properties-tests.ts b/apps/automated/src/ui/styling/style-properties-tests.ts
index 2f86322760..ef484ed647 100644
--- a/apps/automated/src/ui/styling/style-properties-tests.ts
+++ b/apps/automated/src/ui/styling/style-properties-tests.ts
@@ -115,6 +115,30 @@ export function test_setting_minHeight_dip_property_from_CSS_is_applied_to_Style
 	test_property_from_CSS_is_applied_to_style('minHeight', 'min-height', 200, '200dip', true);
 }
 
+export function test_setting_maxWidth_property_from_CSS_is_applied_to_Style() {
+	test_property_from_CSS_is_applied_to_style('maxWidth', 'max-width', 200, '200', true);
+}
+
+export function test_setting_maxWidth_dip_property_from_CSS_is_applied_to_Style() {
+	test_property_from_CSS_is_applied_to_style('maxWidth', 'max-width', 200, '200dip', true);
+}
+
+export function test_setting_maxWidth_percent_property_from_CSS_is_applied_to_Style() {
+	test_property_from_CSS_is_applied_to_style('maxWidth', 'max-width', { value: 0.5, unit: '%' }, '50%', true);
+}
+
+export function test_setting_maxHeight_property_from_CSS_is_applied_to_Style() {
+	test_property_from_CSS_is_applied_to_style('maxHeight', 'max-height', 200, '200', true);
+}
+
+export function test_setting_maxHeight_dip_property_from_CSS_is_applied_to_Style() {
+	test_property_from_CSS_is_applied_to_style('maxHeight', 'max-height', 200, '200dip', true);
+}
+
+export function test_setting_maxHeight_percent_property_from_CSS_is_applied_to_Style() {
+	test_property_from_CSS_is_applied_to_style('maxHeight', 'max-height', { value: 0.5, unit: '%' }, '50%', true);
+}
+
 export function test_setting_verticalAlignment_property_from_CSS_is_applied_to_Style() {
 	test_property_from_CSS_is_applied_to_style('verticalAlignment', 'vertical-align', 'bottom');
 }
@@ -214,6 +238,14 @@ export function test_minHeight_property_is_synced_in_style_and_view() {
 	test_property_is_synced_in_style_and_view('minHeight', 200);
 }
 
+export function test_maxWidth_property_is_synced_in_style_and_view() {
+	test_property_is_synced_in_style_and_view('maxWidth', 200);
+}
+
+export function test_maxHeight_property_is_synced_in_style_and_view() {
+	test_property_is_synced_in_style_and_view('maxHeight', 200);
+}
+
 export function test_verticalAlignment_property_is_synced_in_style_and_view() {
 	test_property_is_synced_in_style_and_view('verticalAlignment', 'bottom');
 }
diff --git a/packages/core/platforms/android/widgets-release.aar b/packages/core/platforms/android/widgets-release.aar
index f8b6ccb7cc..9e25101e0d 100644
Binary files a/packages/core/platforms/android/widgets-release.aar and b/packages/core/platforms/android/widgets-release.aar differ
diff --git a/packages/core/ui/core/view-base/index.ts b/packages/core/ui/core/view-base/index.ts
index 5028125779..d4f7b3fd2c 100644
--- a/packages/core/ui/core/view-base/index.ts
+++ b/packages/core/ui/core/view-base/index.ts
@@ -530,6 +530,8 @@ export abstract class ViewBase extends Observable {
 
 	public effectiveMinWidth: number;
 	public effectiveMinHeight: number;
+	public effectiveMaxWidth: number;
+	public effectiveMaxHeight: number;
 	public effectiveWidth: number;
 	public effectiveHeight: number;
 	public effectiveMarginTop: number;
@@ -1550,6 +1552,9 @@ ViewBase.prototype._oldBottom = 0;
 
 ViewBase.prototype.effectiveMinWidth = 0;
 ViewBase.prototype.effectiveMinHeight = 0;
+// Infinity means unconstrained, so Math.min(measured, effectiveMaxWidth) is a no-op when unset.
+ViewBase.prototype.effectiveMaxWidth = Number.POSITIVE_INFINITY;
+ViewBase.prototype.effectiveMaxHeight = Number.POSITIVE_INFINITY;
 ViewBase.prototype.effectiveWidth = 0;
 ViewBase.prototype.effectiveHeight = 0;
 ViewBase.prototype.effectiveMarginTop = 0;
diff --git a/packages/core/ui/core/view/index.android.ts b/packages/core/ui/core/view/index.android.ts
index df2fcf51b2..d5c2d89d22 100644
--- a/packages/core/ui/core/view/index.android.ts
+++ b/packages/core/ui/core/view/index.android.ts
@@ -9,7 +9,7 @@ import { ShowModalOptions, hiddenProperty } from '../view-base';
 import { isCssWideKeyword } from '../properties/property-shared';
 import { EventData } from '../../../data/observable';
 
-import { perspectiveProperty, visibilityProperty, opacityProperty, horizontalAlignmentProperty, verticalAlignmentProperty, minWidthProperty, minHeightProperty, widthProperty, heightProperty, marginLeftProperty, marginTopProperty, marginRightProperty, marginBottomProperty, rotateProperty, rotateXProperty, rotateYProperty, scaleXProperty, scaleYProperty, translateXProperty, translateYProperty, zIndexProperty, backgroundInternalProperty, androidElevationProperty, androidDynamicElevationOffsetProperty } from '../../styling/style-properties';
+import { perspectiveProperty, visibilityProperty, opacityProperty, horizontalAlignmentProperty, verticalAlignmentProperty, minWidthProperty, minHeightProperty, maxWidthProperty, maxHeightProperty, widthProperty, heightProperty, marginLeftProperty, marginTopProperty, marginRightProperty, marginBottomProperty, rotateProperty, rotateXProperty, rotateYProperty, scaleXProperty, scaleYProperty, translateXProperty, translateYProperty, zIndexProperty, backgroundInternalProperty, androidElevationProperty, androidDynamicElevationOffsetProperty } from '../../styling/style-properties';
 import { CoreTypes } from '../../../core-types';
 
 import { Background, BackgroundClearFlags, refreshBorderDrawable } from '../../styling/background';
@@ -2000,3 +2000,25 @@ createNativePercentLengthProperty({
 		return org.nativescript.widgets.ViewHelper.setMinHeight;
 	},
 });
+
+createNativePercentLengthProperty({
+	setter: maxWidthProperty.setNative,
+	auto: -1, // -1 means unconstrained (no maximum).
+	get setPixels() {
+		return org.nativescript.widgets.ViewHelper.setMaxWidth;
+	},
+	get setPercent() {
+		return org.nativescript.widgets.ViewHelper.setMaxWidthPercent;
+	},
+});
+
+createNativePercentLengthProperty({
+	setter: maxHeightProperty.setNative,
+	auto: -1, // -1 means unconstrained (no maximum).
+	get setPixels() {
+		return org.nativescript.widgets.ViewHelper.setMaxHeight;
+	},
+	get setPercent() {
+		return org.nativescript.widgets.ViewHelper.setMaxHeightPercent;
+	},
+});
diff --git a/packages/core/ui/core/view/index.d.ts b/packages/core/ui/core/view/index.d.ts
index 4d46c45aa7..7f5f89d35e 100644
--- a/packages/core/ui/core/view/index.d.ts
+++ b/packages/core/ui/core/view/index.d.ts
@@ -416,6 +416,22 @@ export abstract class View extends ViewCommon {
 	 */
 	minHeight: CoreTypes.LengthType;
 
+	/**
+	 * Gets or sets the maximum width the view may grow to. Accepts a fixed length
+	 * or a percentage of the available width. Defaults to 'auto' (no maximum).
+	 *
+	 * @nsProperty
+	 */
+	maxWidth: CoreTypes.PercentLengthType;
+
+	/**
+	 * Gets or sets the maximum height the view may grow to. Accepts a fixed length
+	 * or a percentage of the available height. Defaults to 'auto' (no maximum).
+	 *
+	 * @nsProperty
+	 */
+	maxHeight: CoreTypes.PercentLengthType;
+
 	/**
 	 * Gets or sets the desired width of the view.
 	 *
diff --git a/packages/core/ui/core/view/index.ios.ts b/packages/core/ui/core/view/index.ios.ts
index 15788eea60..5509c71b90 100644
--- a/packages/core/ui/core/view/index.ios.ts
+++ b/packages/core/ui/core/view/index.ios.ts
@@ -189,8 +189,13 @@ export class View extends ViewCommon {
 			nativeHeight = nativeSize.height;
 		}
 
-		const measureWidth = Math.max(nativeWidth, this.effectiveMinWidth);
-		const measureHeight = Math.max(nativeHeight, this.effectiveMinHeight);
+		let measureWidth = Math.max(nativeWidth, this.effectiveMinWidth);
+		let measureHeight = Math.max(nativeHeight, this.effectiveMinHeight);
+
+		// Clamp to max-width/max-height (effectiveMax* is Infinity when unconstrained).
+		// Applied after min so that max wins when min > max, matching CSS.
+		measureWidth = Math.min(measureWidth, this.effectiveMaxWidth);
+		measureHeight = Math.min(measureHeight, this.effectiveMaxHeight);
 
 		const widthAndState = View.resolveSizeAndState(measureWidth, width, widthMode, 0);
 		const heightAndState = View.resolveSizeAndState(measureHeight, height, heightMode, 0);
diff --git a/packages/core/ui/core/view/view-common.ts b/packages/core/ui/core/view/view-common.ts
index 5ba6c4205d..d9acd51193 100644
--- a/packages/core/ui/core/view/view-common.ts
+++ b/packages/core/ui/core/view/view-common.ts
@@ -72,6 +72,23 @@ type InteractiveTransitionState = { began?: boolean; cancelled?: boolean; option
 // TODO: remove once we fully switch to the new event system
 const warnedEvent = new Set<string>();
 
+// Resolves a max-width/max-height style value to an effective device-pixel constraint.
+// 'auto' (the default) or an unresolvable percent (parent size unknown) means "no maximum",
+// represented as Infinity so that Math.min(measured, effectiveMax) becomes a no-op.
+function resolveEffectiveMax(value: CoreTypes.PercentLengthType, availableSize: number): number {
+	if (value == null || value === 'auto') {
+		return Number.POSITIVE_INFINITY;
+	}
+	// A percent cannot be resolved when the parent size is unspecified (availableSize < 0);
+	// treat it as unconstrained rather than collapsing the view to ~0.
+	if (typeof value === 'object' && (value as CoreTypes.LengthPercentUnit).unit === '%' && availableSize < 0) {
+		return Number.POSITIVE_INFINITY;
+	}
+	const resolved = PercentLength.toDevicePixels(value, Number.POSITIVE_INFINITY, availableSize);
+	// Safety net for any other unresolved/bogus negative result.
+	return resolved < 0 ? Number.POSITIVE_INFINITY : resolved;
+}
+
 export abstract class ViewCommon extends ViewBase {
 	public static layoutChangedEvent = 'layoutChanged';
 	public static shownModallyEvent = 'shownModally';
@@ -765,6 +782,20 @@ export abstract class ViewCommon extends ViewBase {
 		this.style.minHeight = value;
 	}
 
+	get maxWidth(): CoreTypes.PercentLengthType {
+		return this.style.maxWidth;
+	}
+	set maxWidth(value: CoreTypes.PercentLengthType) {
+		this.style.maxWidth = value;
+	}
+
+	get maxHeight(): CoreTypes.PercentLengthType {
+		return this.style.maxHeight;
+	}
+	set maxHeight(value: CoreTypes.PercentLengthType) {
+		this.style.maxHeight = value;
+	}
+
 	get width(): CoreTypes.PercentLengthType {
 		return this.style.width;
 	}
@@ -1225,12 +1256,14 @@ export abstract class ViewCommon extends ViewBase {
 		const availableWidth = parentWidthMeasureMode === layout.UNSPECIFIED ? -1 : parentWidthMeasureSize;
 
 		this.effectiveWidth = PercentLength.toDevicePixels(style.width, -2, availableWidth);
+		this.effectiveMaxWidth = resolveEffectiveMax(style.maxWidth, availableWidth);
 		this.effectiveMarginLeft = PercentLength.toDevicePixels(style.marginLeft, 0, availableWidth);
 		this.effectiveMarginRight = PercentLength.toDevicePixels(style.marginRight, 0, availableWidth);
 
 		const availableHeight = parentHeightMeasureMode === layout.UNSPECIFIED ? -1 : parentHeightMeasureSize;
 
 		this.effectiveHeight = PercentLength.toDevicePixels(style.height, -2, availableHeight);
+		this.effectiveMaxHeight = resolveEffectiveMax(style.maxHeight, availableHeight);
 		this.effectiveMarginTop = PercentLength.toDevicePixels(style.marginTop, 0, availableHeight);
 		this.effectiveMarginBottom = PercentLength.toDevicePixels(style.marginBottom, 0, availableHeight);
 	}
diff --git a/packages/core/ui/core/view/view-helper/view-helper-common.ts b/packages/core/ui/core/view/view-helper/view-helper-common.ts
index 90863943fd..dde8b68f1c 100644
--- a/packages/core/ui/core/view/view-helper/view-helper-common.ts
+++ b/packages/core/ui/core/view/view-helper/view-helper-common.ts
@@ -24,8 +24,8 @@ export class ViewHelper {
 			const horizontalMargins = child.effectiveMarginLeft + child.effectiveMarginRight;
 			const verticalMargins = child.effectiveMarginTop + child.effectiveMarginBottom;
 
-			const childWidthMeasureSpec = ViewHelper.getMeasureSpec(widthMeasureSpec, horizontalMargins, child.effectiveWidth, style.horizontalAlignment === 'stretch');
-			const childHeightMeasureSpec = ViewHelper.getMeasureSpec(heightMeasureSpec, verticalMargins, child.effectiveHeight, style.verticalAlignment === 'stretch');
+			const childWidthMeasureSpec = ViewHelper.getMeasureSpec(widthMeasureSpec, horizontalMargins, child.effectiveWidth, style.horizontalAlignment === 'stretch', child.effectiveMaxWidth);
+			const childHeightMeasureSpec = ViewHelper.getMeasureSpec(heightMeasureSpec, verticalMargins, child.effectiveHeight, style.verticalAlignment === 'stretch', child.effectiveMaxHeight);
 
 			if (Trace.isEnabled()) {
 				Trace.write(`${child.parent} :measureChild: ${child} ${layout.measureSpecToString(childWidthMeasureSpec)}, ${layout.measureSpecToString(childHeightMeasureSpec)}}`, Trace.categories.Layout);
@@ -158,7 +158,7 @@ export class ViewHelper {
 		return curState | newState;
 	}
 
-	private static getMeasureSpec(parentSpec: number, margins: number, childLength: number, stretched: boolean): number {
+	private static getMeasureSpec(parentSpec: number, margins: number, childLength: number, stretched: boolean, maxLength: number = Number.POSITIVE_INFINITY): number {
 		const parentLength = layout.getMeasureSpecSize(parentSpec);
 		const parentSpecMode = layout.getMeasureSpecMode(parentSpec);
 
@@ -196,6 +196,24 @@ export class ViewHelper {
 			}
 		}
 
+		// Apply max-width/max-height: the child may not exceed maxLength. When the parent
+		// is UNSPECIFIED, a finite max turns the spec into an AT_MOST cap so the child is
+		// still bounded; otherwise we shrink the resolved size (and relax EXACTLY to AT_MOST
+		// so a stretched child isn't forced past its max).
+		if (isFinite(maxLength) && maxLength >= 0) {
+			if (resultMode === layout.UNSPECIFIED) {
+				resultSize = maxLength;
+				resultMode = layout.AT_MOST;
+			} else if (resultSize > maxLength) {
+				resultSize = maxLength;
+				// An explicit width/height capped by max is still an exact size (min(width, max)).
+				// A stretched child (no explicit length) should only be bounded, not forced to max.
+				if (resultMode === layout.EXACTLY && childLength < 0) {
+					resultMode = layout.AT_MOST;
+				}
+			}
+		}
+
 		return layout.makeMeasureSpec(resultSize, resultMode);
 	}
 }
diff --git a/packages/core/ui/layouts/absolute-layout/index.ios.ts b/packages/core/ui/layouts/absolute-layout/index.ios.ts
index ae9541a604..f240ed06d8 100644
--- a/packages/core/ui/layouts/absolute-layout/index.ios.ts
+++ b/packages/core/ui/layouts/absolute-layout/index.ios.ts
@@ -40,6 +40,10 @@ export class AbsoluteLayout extends AbsoluteLayoutBase {
 		measureWidth = Math.max(measureWidth, this.effectiveMinWidth);
 		measureHeight = Math.max(measureHeight, this.effectiveMinHeight);
 
+		// Check against our maximum sizes (Infinity when unconstrained)
+		measureWidth = Math.min(measureWidth, this.effectiveMaxWidth);
+		measureHeight = Math.min(measureHeight, this.effectiveMaxHeight);
+
 		const widthAndState = View.resolveSizeAndState(measureWidth, width, widthMode, 0);
 		const heightAndState = View.resolveSizeAndState(measureHeight, height, heightMode, 0);
 
diff --git a/packages/core/ui/layouts/dock-layout/index.ios.ts b/packages/core/ui/layouts/dock-layout/index.ios.ts
index 43aafeca63..375389ff6f 100644
--- a/packages/core/ui/layouts/dock-layout/index.ios.ts
+++ b/packages/core/ui/layouts/dock-layout/index.ios.ts
@@ -70,6 +70,10 @@ export class DockLayout extends DockLayoutBase {
 		measureWidth = Math.max(measureWidth, this.effectiveMinWidth);
 		measureHeight = Math.max(measureHeight, this.effectiveMinHeight);
 
+		// Check against our maximum sizes (Infinity when unconstrained)
+		measureWidth = Math.min(measureWidth, this.effectiveMaxWidth);
+		measureHeight = Math.min(measureHeight, this.effectiveMaxHeight);
+
 		const widthAndState = View.resolveSizeAndState(measureWidth, width, widthMode, 0);
 		const heightAndState = View.resolveSizeAndState(measureHeight, height, heightMode, 0);
 
diff --git a/packages/core/ui/layouts/flexbox-layout/index.ios.ts b/packages/core/ui/layouts/flexbox-layout/index.ios.ts
index 213f0d0ae3..86fca52268 100644
--- a/packages/core/ui/layouts/flexbox-layout/index.ios.ts
+++ b/packages/core/ui/layouts/flexbox-layout/index.ios.ts
@@ -9,7 +9,6 @@ import EXACTLY = layout.EXACTLY;
 import AT_MOST = layout.AT_MOST;
 import UNSPECIFIED = layout.UNSPECIFIED;
 
-import MEASURED_SIZE_MASK = layout.MEASURED_SIZE_MASK;
 import MEASURED_STATE_TOO_SMALL = layout.MEASURED_STATE_TOO_SMALL;
 
 function requestFlexboxLayout(this: View, value) {
@@ -29,9 +28,6 @@ const WRAP_CONTENT = -2;
 
 const View_sUseZeroUnspecifiedMeasureSpec = true; // NOTE: android version < M
 
-// Long ints may not be safe in JavaScript
-const MAX_SIZE = 0x00ffffff & MEASURED_SIZE_MASK;
-
 import makeMeasureSpec = layout.makeMeasureSpec;
 import getMeasureSpecMode = layout.getMeasureSpecMode;
 import getMeasureSpecSize = layout.getMeasureSpecSize;
@@ -433,9 +429,9 @@ export class FlexboxLayout extends FlexboxLayoutBase {
 		if (view.getMeasuredWidth() < minWidth) {
 			needsMeasure = true;
 			childWidth = minWidth;
-		} else if (view.getMeasuredWidth() > MAX_SIZE /*lp.maxWidth*/) {
+		} else if (view.getMeasuredWidth() > view.effectiveMaxWidth) {
 			needsMeasure = true;
-			childWidth = MAX_SIZE /*lp.maxWidth*/;
+			childWidth = view.effectiveMaxWidth;
 		}
 
 		const minHeight = view.effectiveMinHeight;
@@ -443,9 +439,9 @@ export class FlexboxLayout extends FlexboxLayoutBase {
 		if (childHeight < minHeight) {
 			needsMeasure = true;
 			childHeight = minHeight;
-		} else if (childHeight > MAX_SIZE /*lp.maxWidth*/) {
+		} else if (childHeight > view.effectiveMaxHeight) {
 			needsMeasure = true;
-			childHeight = MAX_SIZE /*lp.maxWidth*/;
+			childHeight = view.effectiveMaxHeight;
 		}
 		if (needsMeasure) {
 			view.measure(makeMeasureSpec(childWidth, EXACTLY), makeMeasureSpec(childHeight, EXACTLY));
@@ -535,10 +531,10 @@ export class FlexboxLayout extends FlexboxLayoutBase {
 					const flexGrow = FlexboxLayout.getFlexGrow(child);
 					const rawCalculatedWidth = child.getMeasuredWidth() + unitSpace * flexGrow + accumulatedRoundError;
 					let roundedCalculatedWidth = Math.round(rawCalculatedWidth);
-					// TODO: MAX_SIZE is so big, this is always false:
-					if (roundedCalculatedWidth > MAX_SIZE /* lp.maxWidth */) {
+					// Freeze the child once flex-grow would push it past its max-width (Infinity when unconstrained).
+					if (roundedCalculatedWidth > child.effectiveMaxWidth) {
 						needsReexpand = true;
-						roundedCalculatedWidth = MAX_SIZE /* lp.maxWidth */;
+						roundedCalculatedWidth = child.effectiveMaxWidth;
 						this._childrenFrozen[childIndex] = true;
 						flexLine._totalFlexGrow -= flexGrow;
 					} else {
@@ -552,10 +548,10 @@ export class FlexboxLayout extends FlexboxLayoutBase {
 					const flexGrow = FlexboxLayout.getFlexGrow(child);
 					const rawCalculatedHeight = child.getMeasuredHeight() + unitSpace * flexGrow + accumulatedRoundError;
 					let roundedCalculatedHeight = Math.round(rawCalculatedHeight);
-					// TODO: MAX_SIZE is so big this is always false:
-					if (roundedCalculatedHeight > MAX_SIZE /*lp.maxHeight*/) {
+					// Freeze the child once flex-grow would push it past its max-height (Infinity when unconstrained).
+					if (roundedCalculatedHeight > child.effectiveMaxHeight) {
 						needsReexpand = true;
-						roundedCalculatedHeight = MAX_SIZE /*lp.maxHeight*/;
+						roundedCalculatedHeight = child.effectiveMaxHeight;
 						this._childrenFrozen[childIndex] = true;
 						flexLine._totalFlexGrow -= flexGrow;
 					} else {
diff --git a/packages/core/ui/layouts/grid-layout/index.ios.ts b/packages/core/ui/layouts/grid-layout/index.ios.ts
index ca2e253ec2..0b376cc8f1 100644
--- a/packages/core/ui/layouts/grid-layout/index.ios.ts
+++ b/packages/core/ui/layouts/grid-layout/index.ios.ts
@@ -154,6 +154,10 @@ export class GridLayout extends GridLayoutBase {
 		measureWidth = Math.max(measureWidth, this.effectiveMinWidth);
 		measureHeight = Math.max(measureHeight, this.effectiveMinHeight);
 
+		// Check against our maximum sizes (Infinity when unconstrained)
+		measureWidth = Math.min(measureWidth, this.effectiveMaxWidth);
+		measureHeight = Math.min(measureHeight, this.effectiveMaxHeight);
+
 		const widthSizeAndState = View.resolveSizeAndState(measureWidth, width, widthMode, 0);
 		const heightSizeAndState = View.resolveSizeAndState(measureHeight, height, heightMode, 0);
 
diff --git a/packages/core/ui/layouts/stack-layout/index.ios.ts b/packages/core/ui/layouts/stack-layout/index.ios.ts
index 1239bda48e..a518fa3768 100644
--- a/packages/core/ui/layouts/stack-layout/index.ios.ts
+++ b/packages/core/ui/layouts/stack-layout/index.ios.ts
@@ -83,6 +83,10 @@ export class StackLayout extends StackLayoutBase {
 		measureWidth = Math.max(measureWidth, this.effectiveMinWidth);
 		measureHeight = Math.max(measureHeight, this.effectiveMinHeight);
 
+		// Check against our maximum sizes (Infinity when unconstrained)
+		measureWidth = Math.min(measureWidth, this.effectiveMaxWidth);
+		measureHeight = Math.min(measureHeight, this.effectiveMaxHeight);
+
 		this._totalLength = isVertical ? measureHeight : measureWidth;
 
 		const widthAndState = View.resolveSizeAndState(measureWidth, width, widthMode, 0);
diff --git a/packages/core/ui/layouts/wrap-layout/index.ios.ts b/packages/core/ui/layouts/wrap-layout/index.ios.ts
index 50ef35c55a..5b008e1f02 100644
--- a/packages/core/ui/layouts/wrap-layout/index.ios.ts
+++ b/packages/core/ui/layouts/wrap-layout/index.ios.ts
@@ -108,6 +108,10 @@ export class WrapLayout extends WrapLayoutBase {
 		measureWidth = Math.max(measureWidth, this.effectiveMinWidth);
 		measureHeight = Math.max(measureHeight, this.effectiveMinHeight);
 
+		// Check against our maximum sizes (Infinity when unconstrained)
+		measureWidth = Math.min(measureWidth, this.effectiveMaxWidth);
+		measureHeight = Math.min(measureHeight, this.effectiveMaxHeight);
+
 		const widthAndState = View.resolveSizeAndState(measureWidth, width, widthMode, 0);
 		const heightAndState = View.resolveSizeAndState(measureHeight, height, heightMode, 0);
 
diff --git a/packages/core/ui/styling/style-properties.ts b/packages/core/ui/styling/style-properties.ts
index 9461c1a476..36db9115b2 100644
--- a/packages/core/ui/styling/style-properties.ts
+++ b/packages/core/ui/styling/style-properties.ts
@@ -350,6 +350,32 @@ export const heightProperty = new CssAnimationProperty<Style, CoreTypes.PercentL
 });
 heightProperty.register(Style);
 
+export const maxWidthProperty = new CssProperty<Style, CoreTypes.PercentLengthType>({
+	name: 'maxWidth',
+	cssName: 'max-width',
+	// 'auto' means unconstrained (no maximum).
+	defaultValue: 'auto',
+	affectsLayout: global.isIOS,
+	equalityComparer: Length.equals,
+	// The effective pixel value is resolved at measure time in
+	// View._updateEffectiveLayoutValues (percent needs the parent size), so we
+	// only need to trigger a relayout here. On iOS that is done via affectsLayout;
+	// on Android the native setNative handler applies it and re-measures.
+	valueConverter: PercentLength.parse,
+});
+maxWidthProperty.register(Style);
+
+export const maxHeightProperty = new CssProperty<Style, CoreTypes.PercentLengthType>({
+	name: 'maxHeight',
+	cssName: 'max-height',
+	// 'auto' means unconstrained (no maximum).
+	defaultValue: 'auto',
+	affectsLayout: global.isIOS,
+	equalityComparer: Length.equals,
+	valueConverter: PercentLength.parse,
+});
+maxHeightProperty.register(Style);
+
 const marginProperty = new ShorthandProperty<Style, string | CoreTypes.PercentLengthType>({
 	name: 'margin',
 	cssName: 'margin',
diff --git a/packages/core/ui/styling/style/index.ts b/packages/core/ui/styling/style/index.ts
index e1015c256e..33502414ea 100644
--- a/packages/core/ui/styling/style/index.ts
+++ b/packages/core/ui/styling/style/index.ts
@@ -183,6 +183,8 @@ export class Style extends Observable {
 
 	public minWidth: CoreTypes.LengthType;
 	public minHeight: CoreTypes.LengthType;
+	public maxWidth: CoreTypes.PercentLengthType;
+	public maxHeight: CoreTypes.PercentLengthType;
 	public width: CoreTypes.PercentLengthType;
 	public height: CoreTypes.PercentLengthType;
 	public margin: string | CoreTypes.PercentLengthType;
diff --git a/packages/types-android/src/lib/android/org.nativescript.widgets.d.ts b/packages/types-android/src/lib/android/org.nativescript.widgets.d.ts
index 870ccd5a42..72cf1d8d49 100644
--- a/packages/types-android/src/lib/android/org.nativescript.widgets.d.ts
+++ b/packages/types-android/src/lib/android/org.nativescript.widgets.d.ts
@@ -181,6 +181,11 @@
                 public widthPercent: number;
                 public heightPercent: number;
 
+                public maxWidth: number;
+                public maxHeight: number;
+                public maxWidthPercent: number;
+                public maxHeightPercent: number;
+
                 public topMarginPercent: number;
                 public leftMarginPercent: number;
                 public bottomMarginPercent: number;
@@ -601,6 +606,14 @@
                 public static getMinHeight(view: android.view.View): number;
                 public static setMinHeight(view: android.view.View, value: number): void;
 
+                public static getMaxWidth(view: android.view.View): number;
+                public static setMaxWidth(view: android.view.View, value: number): void;
+                public static setMaxWidthPercent(view: android.view.View, value: number): void;
+
+                public static getMaxHeight(view: android.view.View): number;
+                public static setMaxHeight(view: android.view.View, value: number): void;
+                public static setMaxHeightPercent(view: android.view.View, value: number): void;
+
                 public static getWidth(view: android.view.View): number;
                 public static setWidth(view: android.view.View, value: number): void;
                 public static setWidthPercent(view: android.view.View, value: number): void;
diff --git a/packages/ui-mobile-base/android/widgets/src/main/java/org/nativescript/widgets/CommonLayoutParams.java b/packages/ui-mobile-base/android/widgets/src/main/java/org/nativescript/widgets/CommonLayoutParams.java
index 3f01913428..a394d126a7 100644
--- a/packages/ui-mobile-base/android/widgets/src/main/java/org/nativescript/widgets/CommonLayoutParams.java
+++ b/packages/ui-mobile-base/android/widgets/src/main/java/org/nativescript/widgets/CommonLayoutParams.java
@@ -48,6 +48,11 @@ public CommonLayoutParams(CommonLayoutParams source) {
 		this.widthPercent = source.widthPercent;
 		this.heightPercent = source.heightPercent;
 
+		this.maxWidth = source.maxWidth;
+		this.maxHeight = source.maxHeight;
+		this.maxWidthPercent = source.maxWidthPercent;
+		this.maxHeightPercent = source.maxHeightPercent;
+
 		this.topMargin = source.topMargin;
 		this.leftMargin = source.leftMargin;
 		this.bottomMargin = source.bottomMargin;
@@ -65,6 +70,14 @@ public CommonLayoutParams(CommonLayoutParams source) {
 	public float widthPercent = 0;
 	public float heightPercent = 0;
 
+	// max-width / max-height. -1 means unconstrained (no maximum).
+	public int maxWidth = -1;
+	public int maxHeight = -1;
+	public float maxWidthPercent = 0;
+	public float maxHeightPercent = 0;
+	public int maxWidthOriginal = NOT_SET;
+	public int maxHeightOriginal = NOT_SET;
+
 	public float topMarginPercent = 0;
 	public float leftMarginPercent = 0;
 	public float bottomMarginPercent = 0;
@@ -296,6 +309,15 @@ protected static void adjustChildrenLayoutParams(ViewGroup viewGroup, int widthM
 						lp.widthOriginal = NOT_SET;
 					}
 
+					if (lp.maxWidthPercent > 0) {
+						if (lp.maxWidthOriginal == NOT_SET) {
+							lp.maxWidthOriginal = lp.maxWidth;
+						}
+						lp.maxWidth = (int) (availableWidth * lp.maxWidthPercent);
+					} else {
+						lp.maxWidthOriginal = NOT_SET;
+					}
+
 					if (lp.leftMarginPercent > 0) {
 						if (lp.leftMarginOriginal == NOT_SET) {
 							lp.leftMarginOriginal = lp.leftMargin;
@@ -325,6 +347,15 @@ protected static void adjustChildrenLayoutParams(ViewGroup viewGroup, int widthM
 						lp.heightOriginal = NOT_SET;
 					}
 
+					if (lp.maxHeightPercent > 0) {
+						if (lp.maxHeightOriginal == NOT_SET) {
+							lp.maxHeightOriginal = lp.maxHeight;
+						}
+						lp.maxHeight = (int) (availableHeight * lp.maxHeightPercent);
+					} else {
+						lp.maxHeightOriginal = NOT_SET;
+					}
+
 					if (lp.topMarginPercent > 0) {
 						if (lp.topMarginOriginal == NOT_SET) {
 							lp.topMarginOriginal = lp.topMargin;
@@ -363,6 +394,12 @@ protected static void restoreOriginalParams(ViewGroup viewGroup) {
 				if (lp.heightPercent > 0) {
 					lp.height = lp.heightOriginal;
 				}
+				if (lp.maxWidthPercent > 0) {
+					lp.maxWidth = lp.maxWidthOriginal;
+				}
+				if (lp.maxHeightPercent > 0) {
+					lp.maxHeight = lp.maxHeightOriginal;
+				}
 				if (lp.leftMarginPercent > 0) {
 					lp.leftMargin = lp.leftMarginOriginal;
 				}
@@ -378,6 +415,8 @@ protected static void restoreOriginalParams(ViewGroup viewGroup) {
 
 				lp.widthOriginal = NOT_SET;
 				lp.heightOriginal = NOT_SET;
+				lp.maxWidthOriginal = NOT_SET;
+				lp.maxHeightOriginal = NOT_SET;
 				lp.leftMarginOriginal = NOT_SET;
 				lp.topMarginOriginal = NOT_SET;
 				lp.rightMarginOriginal = NOT_SET;
@@ -451,6 +490,23 @@ private static int getMeasureSpec(View view, int parentMeasureSpec, boolean hori
 			}
 		}
 
+		// Apply max-width / max-height: the child may not exceed max. When the parent is
+		// UNSPECIFIED, a max turns the spec into an AT_MOST cap so the child stays bounded;
+		// otherwise we shrink the resolved size (relaxing a stretched EXACTLY to AT_MOST so
+		// the child isn't forced past its max, while an explicit size stays EXACTLY at max).
+		int max = horizontal ? lp.maxWidth : lp.maxHeight;
+		if (max >= 0) {
+			if (resultMode == MeasureSpec.UNSPECIFIED) {
+				resultSize = max;
+				resultMode = MeasureSpec.AT_MOST;
+			} else if (resultSize > max) {
+				resultSize = max;
+				if (resultMode == MeasureSpec.EXACTLY && childLength < 0) {
+					resultMode = MeasureSpec.AT_MOST;
+				}
+			}
+		}
+
 		return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
 	}
 }
diff --git a/packages/ui-mobile-base/android/widgets/src/main/java/org/nativescript/widgets/FlexboxLayout.java b/packages/ui-mobile-base/android/widgets/src/main/java/org/nativescript/widgets/FlexboxLayout.java
index 8e5991afc2..c1cd29c028 100644
--- a/packages/ui-mobile-base/android/widgets/src/main/java/org/nativescript/widgets/FlexboxLayout.java
+++ b/packages/ui-mobile-base/android/widgets/src/main/java/org/nativescript/widgets/FlexboxLayout.java
@@ -846,7 +846,7 @@ private void checkSizeConstraints(View view) {
 		if (view.getMeasuredWidth() < lp.minWidth) {
 			needsMeasure = true;
 			childWidth = lp.minWidth;
-		} else if (view.getMeasuredWidth() > lp.maxWidth) {
+		} else if (lp.maxWidth >= 0 && view.getMeasuredWidth() > lp.maxWidth) {
 			needsMeasure = true;
 			childWidth = lp.maxWidth;
 		}
@@ -854,7 +854,7 @@ private void checkSizeConstraints(View view) {
 		if (childHeight < lp.minHeight) {
 			needsMeasure = true;
 			childHeight = lp.minHeight;
-		} else if (childHeight > lp.maxHeight) {
+		} else if (lp.maxHeight >= 0 && childHeight > lp.maxHeight) {
 			needsMeasure = true;
 			childHeight = lp.maxHeight;
 		}
@@ -984,7 +984,7 @@ private int expandFlexItems(FlexLine flexLine, @FlexDirection int flexDirection,
 				if (!mChildrenFrozen[childIndex]) {
 					float rawCalculatedWidth = child.getMeasuredWidth() + unitSpace * lp.flexGrow + accumulatedRoundError;
 					int roundedCalculatedWidth = Math.round(rawCalculatedWidth);
-					if (roundedCalculatedWidth > lp.maxWidth) {
+					if (lp.maxWidth >= 0 && roundedCalculatedWidth > lp.maxWidth) {
 						// This means the child can't expand beyond the value of the maxWidth attribute.
 						// To adjust the flex line length to the size of maxMainSize, remaining
 						// positive free space needs to be re-distributed to other flex items
@@ -1008,7 +1008,7 @@ private int expandFlexItems(FlexLine flexLine, @FlexDirection int flexDirection,
 				if (!mChildrenFrozen[childIndex]) {
 					float rawCalculatedHeight = child.getMeasuredHeight() + unitSpace * lp.flexGrow;
 					int roundedCalculatedHeight = Math.round(rawCalculatedHeight);
-					if (roundedCalculatedHeight > lp.maxHeight) {
+					if (lp.maxHeight >= 0 && roundedCalculatedHeight > lp.maxHeight) {
 						// This means the child can't expand beyond the value of the maxHeight
 						// attribute.
 						// To adjust the flex line length to the size of maxMainSize, remaining
@@ -2623,8 +2623,6 @@ public static class LayoutParams extends CommonLayoutParams {
 
 		public static final int ALIGN_SELF_STRETCH = ALIGN_ITEMS_STRETCH;
 
-		private static final int MAX_SIZE = Integer.MAX_VALUE & View.MEASURED_SIZE_MASK;
-
 		/**
 		 * This attribute can change the ordering of the children views are laid out.
 		 * By default, children are displayed and laid out in the same order as they appear in the
@@ -2680,15 +2678,9 @@ public static class LayoutParams extends CommonLayoutParams {
 		 */
 		public int minHeight;
 
-		/**
-		 * This attribute determines the maximum width the child can expand to.
-		 */
-		public int maxWidth = MAX_SIZE;
-
-		/**
-		 * This attribute determines the maximum height the child can expand to.
-		 */
-		public int maxHeight = MAX_SIZE;
+		// maxWidth / maxHeight are inherited from CommonLayoutParams (-1 means unconstrained),
+		// so that the max-width / max-height style properties, including percent values resolved
+		// in CommonLayoutParams.adjustChildrenLayoutParams, are honored inside flexbox as well.
 
 		/**
 		 * This attribute forces a flex line wrapping. i.e. if this is set to {@code true} for a
diff --git a/packages/ui-mobile-base/android/widgets/src/main/java/org/nativescript/widgets/ViewHelper.java b/packages/ui-mobile-base/android/widgets/src/main/java/org/nativescript/widgets/ViewHelper.java
index 733981a246..bc685fa8f7 100644
--- a/packages/ui-mobile-base/android/widgets/src/main/java/org/nativescript/widgets/ViewHelper.java
+++ b/packages/ui-mobile-base/android/widgets/src/main/java/org/nativescript/widgets/ViewHelper.java
@@ -42,6 +42,84 @@ public static void setMinHeight(android.view.View view, int value) {
 		view.setMinimumHeight(value);
 	}
 
+	public static int getMaxWidth(android.view.View view) {
+		ViewGroup.LayoutParams params = view.getLayoutParams();
+		if (params instanceof CommonLayoutParams) {
+			return ((CommonLayoutParams) params).maxWidth;
+		}
+
+		return -1;
+	}
+
+	// value < 0 (e.g. the JS "auto" sentinel of -1) means unconstrained.
+	public static void setMaxWidth(android.view.View view, int value) {
+		ViewGroup.LayoutParams params = view.getLayoutParams();
+		if (params == null) {
+			params = new CommonLayoutParams();
+		}
+
+		if (params instanceof CommonLayoutParams) {
+			CommonLayoutParams lp = (CommonLayoutParams) params;
+			lp.maxWidth = value;
+			lp.maxWidthPercent = 0;
+			view.setLayoutParams(params);
+		}
+	}
+
+	public static void setMaxWidthPercent(android.view.View view, float value) {
+		ViewGroup.LayoutParams params = view.getLayoutParams();
+		if (params == null) {
+			params = new CommonLayoutParams();
+		}
+
+		if (params instanceof CommonLayoutParams) {
+			CommonLayoutParams lp = (CommonLayoutParams) params;
+			lp.maxWidthPercent = value;
+			// Baseline is unconstrained; the percent is resolved against the parent at measure time.
+			lp.maxWidth = -1;
+			view.setLayoutParams(params);
+		}
+	}
+
+	public static int getMaxHeight(android.view.View view) {
+		ViewGroup.LayoutParams params = view.getLayoutParams();
+		if (params instanceof CommonLayoutParams) {
+			return ((CommonLayoutParams) params).maxHeight;
+		}
+
+		return -1;
+	}
+
+	// value < 0 (e.g. the JS "auto" sentinel of -1) means unconstrained.
+	public static void setMaxHeight(android.view.View view, int value) {
+		ViewGroup.LayoutParams params = view.getLayoutParams();
+		if (params == null) {
+			params = new CommonLayoutParams();
+		}
+
+		if (params instanceof CommonLayoutParams) {
+			CommonLayoutParams lp = (CommonLayoutParams) params;
+			lp.maxHeight = value;
+			lp.maxHeightPercent = 0;
+			view.setLayoutParams(params);
+		}
+	}
+
+	public static void setMaxHeightPercent(android.view.View view, float value) {
+		ViewGroup.LayoutParams params = view.getLayoutParams();
+		if (params == null) {
+			params = new CommonLayoutParams();
+		}
+
+		if (params instanceof CommonLayoutParams) {
+			CommonLayoutParams lp = (CommonLayoutParams) params;
+			lp.maxHeightPercent = value;
+			// Baseline is unconstrained; the percent is resolved against the parent at measure time.
+			lp.maxHeight = -1;
+			view.setLayoutParams(params);
+		}
+	}
+
 	public static int getWidth(android.view.View view) {
 		ViewGroup.LayoutParams params = view.getLayoutParams();
 		if (params != null) {
diff --git a/packages/ui-mobile-base/native-build-state.json b/packages/ui-mobile-base/native-build-state.json
index 693fdcc6d9..b3c43f8477 100644
--- a/packages/ui-mobile-base/native-build-state.json
+++ b/packages/ui-mobile-base/native-build-state.json
@@ -5,7 +5,7 @@
 		"artifactHash": "sha256:71ac91f0e4290e8a38d253649a73cdeef87e5bfa10e013ead5f61eecd57aff70"
 	},
 	"android": {
-		"sourceHash": "sha256:f9c3ab1e307acc94e267a7b05c9b50f4ea8d606936cb9363d3c98ee1c1080f42",
-		"artifactHash": "sha256:a07a9d2a9bae05459c75666d5fccba26694d24b602b445db3d88603abd5efc74"
+		"sourceHash": "sha256:7a822f5f9d32b2b12ea28f1aeb6f46e0cb0285c764cbe1465d1bc7829205d6af",
+		"artifactHash": "sha256:ed51bcfbbf8ff9b44d3c93ddf179a4a7b148adfba2de3cdabfea546a587b15ec"
 	}
 }